4runr-os-mk3 0.1.1 → 0.1.2

package/src/io/mod.rs

@@ -0,0 +1,66 @@
+mod protocol;
+mod stdio;
+mod ws;
+
+use crate::app::{App, Message};
+use anyhow::Result;
+use serde_json;
+use std::io::Write;
+use std::sync::mpsc;
+use std::thread;
+
+pub struct IoHandler {
+    receiver: mpsc::Receiver<Message>,
+    #[allow(dead_code)]
+    sender: mpsc::Sender<String>,
+}
+
+impl IoHandler {
+    pub fn new() -> Result<Self> {
+        let (_tx, rx) = mpsc::channel();
+        let (cmd_tx, _cmd_rx) = mpsc::channel();
+
+        // DO NOT spawn any IO threads that read from stdin!
+        // The TUI needs exclusive access to stdin for keyboard input.
+        // Future: use WebSocket or named pipe for backend communication.
+        
+        // Command sender thread (writes to stdout, but doesn't block stdin)
+        thread::spawn(move || {
+            loop {
+                match _cmd_rx.recv() {
+                    Ok(cmd) => {
+                        let cmd_json = serde_json::json!({
+                            "type": "command",
+                            "text": cmd
+                        });
+                        if let Ok(json_str) = serde_json::to_string(&cmd_json) {
+                            println!("{}", json_str);
+                            let _ = std::io::stdout().flush();
+                        }
+                    }
+                    Err(_) => break,
+                }
+            }
+        });
+
+        Ok(Self {
+            receiver: rx,
+            sender: cmd_tx,
+        })
+    }
+
+    pub fn update(&mut self, app: &mut App) -> Result<()> {
+        // Non-blocking receive
+        while let Ok(message) = self.receiver.try_recv() {
+            app.update(message);
+        }
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub fn send_command(&mut self, cmd: String) -> Result<()> {
+        self.sender.send(cmd)?;
+        Ok(())
+    }
+}
+

package/src/io/protocol.rs

@@ -0,0 +1,15 @@
+use crate::app::Message;
+use anyhow::Result;
+use std::sync::mpsc;
+
+#[allow(dead_code)]
+pub trait Protocol: Send {
+    fn run(&mut self) -> Result<()>;
+}
+
+#[allow(dead_code)]
+pub struct ProtocolContext {
+    pub message_tx: mpsc::Sender<Message>,
+    pub command_rx: mpsc::Receiver<String>,
+}
+

package/src/io/stdio.rs

@@ -0,0 +1,32 @@
+use crate::app::Message;
+use crate::io::protocol::Protocol;
+use anyhow::Result;
+use std::sync::mpsc;
+
+#[allow(dead_code)]
+pub struct StdioProtocol {
+    #[allow(dead_code)]
+    message_tx: mpsc::Sender<Message>,
+}
+
+impl StdioProtocol {
+    #[allow(dead_code)]
+    pub fn new(message_tx: mpsc::Sender<Message>) -> Result<Self> {
+        Ok(Self { message_tx })
+    }
+}
+
+impl Protocol for StdioProtocol {
+    fn run(&mut self) -> Result<()> {
+        // DO NOT read from stdin here!
+        // The TUI needs stdin for keyboard input via crossterm.
+        // This protocol is a no-op for now.
+        // In the future, we can use a named pipe or socket for IPC.
+        
+        // Just sleep forever to keep the thread alive
+        loop {
+            std::thread::sleep(std::time::Duration::from_secs(3600));
+        }
+    }
+}
+

package/src/io/ws.rs

@@ -0,0 +1,32 @@
+use crate::app::Message;
+use crate::io::protocol::Protocol;
+use anyhow::Result;
+use std::sync::mpsc;
+
+#[allow(dead_code)]
+pub struct WsProtocol {
+    url: String,
+    message_tx: mpsc::Sender<Message>,
+}
+
+impl WsProtocol {
+    #[allow(dead_code)]
+    pub fn new(
+        url: String,
+        message_tx: mpsc::Sender<Message>,
+    ) -> Result<Self> {
+        Ok(Self {
+            url,
+            message_tx,
+        })
+    }
+}
+
+impl Protocol for WsProtocol {
+    fn run(&mut self) -> Result<()> {
+        // This will be implemented with tokio runtime
+        // For now, return error to fallback to stdio
+        anyhow::bail!("WebSocket not yet implemented, use stdio");
+    }
+}
+

package/src/main.rs

@@ -0,0 +1,119 @@
+use anyhow::Result;
+use crossterm::cursor;
+use crossterm::event::{self, Event, KeyEventKind};
+use crossterm::execute;
+use crossterm::terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen, Clear, ClearType};
+use ratatui::prelude::*;
+use std::time::{Duration, Instant};
+
+mod app;
+mod io;
+mod ui;
+
+use app::App;
+use io::IoHandler;
+
+fn main() -> Result<()> {
+    // Setup terminal (boot screen is now part of TUI)
+    enable_raw_mode()?;
+    let mut stdout = std::io::stdout();
+    
+    // Enter alternate screen, hide cursor, clear screen, move to top-left
+    execute!(
+        stdout, 
+        EnterAlternateScreen,
+        cursor::Hide,
+        Clear(ClearType::All),
+        cursor::MoveTo(0, 0)
+    )?;
+    
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+    
+    // Clear the terminal buffer to ensure no artifacts
+    terminal.clear()?;
+
+    // Create app
+    let mut app = App::new();
+    let mut io_handler = IoHandler::new()?;
+    
+    // Track real time for uptime (not from tick counter)
+    let start_time = Instant::now();
+    let mut last_tick = Instant::now();
+    
+    // Force initial render
+    app.request_render("initial");
+
+    // Main loop - CRITICAL FIX: Animations run EVERY iteration, not just when no input!
+    // Per instructions Bug 1 fix: Move tick() and uptime OUTSIDE poll block
+    loop {
+        // ┌─────────────────────────────────────────────────────────┐
+        // │ STEP 1: UPDATE ANIMATIONS (runs EVERY loop iteration)  │
+        // └─────────────────────────────────────────────────────────┘
+        
+        // Uptime - always update from real clock (OUTSIDE poll block)
+        app.state.uptime_secs = start_time.elapsed().as_secs();
+        
+        // Spinner - update on timer (every 150ms) - OUTSIDE poll block
+        if last_tick.elapsed() >= Duration::from_millis(150) {
+            app.tick();  // Advances spinner_frame
+            last_tick = Instant::now();
+        }
+        
+        // ┌─────────────────────────────────────────────────────────┐
+        // │ STEP 2: CHECK RENDER SCHEDULER                        │
+        // └─────────────────────────────────────────────────────────┘
+        // Check if scheduler says we should render
+        if app.should_render() {
+            // Scheduler requested render
+        }
+        
+        // Check input debounce
+        if let Some(debounce_time) = app.input_debounce {
+            let elapsed = debounce_time.elapsed();
+            if elapsed >= app.input_debounce_duration {
+                app.input_debounce = None;
+                app.request_render("input_debounce");
+            }
+        }
+        
+        // ┌─────────────────────────────────────────────────────────┐
+        // │ STEP 3: RENDER (runs EVERY loop iteration)              │
+        // └─────────────────────────────────────────────────────────┘
+        // Always render to show animation updates (animations run every loop)
+        let render_start = Instant::now();
+            terminal.draw(|f| app.render(f))?;
+            let render_duration = render_start.elapsed().as_millis() as u64;
+            app.record_render(render_duration);
+        
+        // ┌─────────────────────────────────────────────────────────┐
+        // │ STEP 4: CHECK FOR INPUT (non-blocking with timeout)    │
+        // └─────────────────────────────────────────────────────────┘
+        // poll() with short timeout (16ms) - returns immediately if no input
+        // This allows loop to run ~60 times/second for smooth animations
+        if crossterm::event::poll(Duration::from_millis(16))? {
+            if let Event::Key(key) = event::read()? {
+                if key.kind == KeyEventKind::Press {
+                    if app.handle_input(key, &mut io_handler)? {
+                        break; // Exit requested
+                    }
+                }
+            }
+        }
+        // If no input, loop continues immediately - animations keep running!
+        
+        // Check for IO updates (non-blocking)
+        io_handler.update(&mut app).ok();
+    }
+
+    // Restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(), 
+        cursor::Show,
+        LeaveAlternateScreen
+    )?;
+
+    Ok(())
+}
+

package/src/ui/boot.rs

@@ -0,0 +1,150 @@
+use crate::app::AppState;
+use ratatui::prelude::*;
+use ratatui::widgets::{Block, Borders, Gauge, Paragraph};
+
+// Color constants matching the TUI palette (exact match from layout.rs)
+const BRAND_PURPLE: Color = Color::Rgb(138, 43, 226);
+#[allow(dead_code)]
+const BRAND_VIOLET: Color = Color::Rgb(148, 103, 189);
+const CYBER_CYAN: Color = Color::Rgb(0, 255, 255);
+const NEON_GREEN: Color = Color::Rgb(57, 255, 20);
+const TEXT_PRIMARY: Color = Color::Rgb(230, 230, 240);
+const TEXT_DIM: Color = Color::Rgb(100, 100, 120);
+#[allow(dead_code)]
+const TEXT_MUTED: Color = Color::Rgb(60, 60, 80);
+const BG_PANEL: Color = Color::Rgb(18, 18, 25);
+
+/// Exact logo from requirements (monospace, preserve spacing)
+const LOGO: &str = r#"██╗  ██╗██████╗ ██╗   ██╗███╗   ██╗██████╗      ██████╗ ███████╗
+██║  ██║██╔══██╗██║   ██║████╗  ██║██╔══██╗    ██╔═══██╗██╔════╝
+███████║██████╔╝██║   ██║██╔██╗ ██║██████╔╝    ██║   ██║███████╗
+╚════██║██╔══██╗██║   ██║██║╚██╗██║██╔══██╗    ██║   ██║╚════██║
+     ██║██║  ██║╚██████╔╝██║ ╚████║██║  ██║    ╚██████╔╝███████║
+     ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝     ╚═════╝ ╚══════╝"#;
+
+pub fn render_boot(f: &mut Frame, area: Rect, state: &AppState) {
+    // Clear background
+    f.render_widget(
+        Block::default().style(Style::default().bg(BG_PANEL)),
+        area,
+    );
+    
+    // Calculate layout: logo on top half, boot logs below, progress bar, footer
+    let logo_height: u16 = 6; // Logo is 6 lines
+    let boot_logs_height: u16 = state.boot_lines.len().min(10) as u16; // Max 10 lines visible
+    let progress_height: u16 = 3;
+    let footer_height: u16 = 1;
+    
+    let total_content_height: u16 = logo_height + 2 + boot_logs_height + 2 + progress_height + 2 + footer_height;
+    let start_y: u16 = (area.height.saturating_sub(total_content_height)) / 2;
+    
+    // === LOGO (centered horizontally and vertically) ===
+    let logo_lines: Vec<&str> = LOGO.lines().collect();
+    let logo_width: u16 = logo_lines.iter().map(|l| l.len()).max().unwrap_or(0) as u16;
+    // Center horizontally: (area.width - logo_width) / 2
+    let logo_x: u16 = area.x + (area.width.saturating_sub(logo_width)) / 2;
+    
+    for (i, line) in logo_lines.iter().enumerate() {
+        let line_y = start_y + i as u16;
+        if line_y < area.height {
+            // Center each line within the available width
+            let line_rect = Rect {
+                x: logo_x,
+                y: line_y,
+                width: logo_width.min(area.width.saturating_sub(logo_x)),
+                height: 1,
+            };
+            f.render_widget(
+                Paragraph::new(*line)
+                    .style(Style::default().fg(BRAND_PURPLE))
+                    .alignment(Alignment::Center), // Center alignment for perfect centering
+                line_rect,
+            );
+        }
+    }
+    
+    let current_y = start_y + logo_height + 2;
+    
+    // === BOOT LOGS ===
+    if !state.boot_lines.is_empty() && current_y < area.height {
+        // Center logs horizontally
+        let logs_width: u16 = (area.width * 60 / 100).min(area.width.saturating_sub(40)); // 60% width, safe margins
+        let logs_x: u16 = area.x + (area.width.saturating_sub(logs_width)) / 2;
+        
+        let logs_area = Rect {
+            x: logs_x,
+            y: current_y,
+            width: logs_width,
+            height: boot_logs_height,
+        };
+        
+        let mut log_text = String::new();
+        for line in state.boot_lines.iter() {
+            log_text.push_str(line);
+            log_text.push('\n');
+        }
+        
+        f.render_widget(
+            Paragraph::new(log_text.trim())
+                .style(Style::default().fg(TEXT_PRIMARY))
+                .alignment(Alignment::Center), // Center logs too
+            logs_area,
+        );
+    }
+    
+    let current_y = current_y + boot_logs_height + 2;
+    
+    // === PROGRESS BAR ===
+    if current_y < area.height {
+        // Center progress bar horizontally
+        let progress_width: u16 = (area.width * 60 / 100).min(area.width.saturating_sub(40));
+        let progress_x: u16 = area.x + (area.width.saturating_sub(progress_width)) / 2;
+        
+        let progress_area = Rect {
+            x: progress_x,
+            y: current_y,
+            width: progress_width,
+            height: 3,
+        };
+        
+        let progress_label = if state.boot_done {
+            "System Ready"
+        } else {
+            "Booting..."
+        };
+        
+        f.render_widget(
+            Gauge::default()
+                .block(
+                    Block::default()
+                        .borders(Borders::NONE)
+                        .title(progress_label)
+                        .title_style(Style::default().fg(CYBER_CYAN))
+                )
+                .gauge_style(Style::default().fg(NEON_GREEN))
+                .percent(state.boot_progress as u16)
+                .label(format!("{}%", state.boot_progress)),
+            progress_area,
+        );
+    }
+    
+    let current_y = current_y + progress_height + 2;
+    
+    // === FOOTER: "Press any key to continue" (only when boot done) ===
+    if state.boot_done && current_y < area.height {
+        let footer_area = Rect {
+            x: area.x,
+            y: current_y,
+            width: area.width,
+            height: footer_height,
+        };
+        
+        f.render_widget(
+            Paragraph::new("Press any key to continue...")
+                .style(Style::default().fg(TEXT_DIM))
+                .alignment(Alignment::Center),
+            footer_area,
+        );
+    }
+}
+