4runr-os 2.10.85 → 2.10.86

package/os-tui/src/debug_log.rs

@@ -0,0 +1,131 @@
+//! File-based debug logger for Setup Portal.
+//! When SETUP_PORTAL_DEBUG=1 or SETUP_PORTAL_DEBUG_FILE is set, all inputs and render state
+//! are written to a file so you can capture the full trace when reproducing the navigation bug.
+//!
+//! Usage:
+//!   set SETUP_PORTAL_DEBUG_FILE=setup-portal-debug.log
+//!   os-tui   (or 4r)
+//! Then open Setup Portal (windowed), reproduce the bug, exit. Inspect setup-portal-debug.log.
+
+use std::io::Write;
+use std::sync::Mutex;
+use std::sync::OnceLock;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+fn enabled() -> bool {
+    std::env::var("SETUP_PORTAL_DEBUG").as_deref() == Ok("1")
+        || std::env::var("SETUP_PORTAL_DEBUG_FILE").is_ok()
+}
+
+fn path() -> String {
+    std::env::var("SETUP_PORTAL_DEBUG_FILE")
+        .unwrap_or_else(|_| "setup-portal-debug.log".to_string())
+}
+
+static FILE: OnceLock<Mutex<Option<std::io::BufWriter<std::fs::File>>>> = OnceLock::new();
+
+fn ensure_open() -> bool {
+    if !enabled() {
+        return false;
+    }
+    let mutex = FILE.get_or_init(|| Mutex::new(None));
+    let mut guard = mutex.lock().unwrap();
+    if guard.is_none() {
+        let path = path();
+        match std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&path)
+        {
+            Ok(file_handle) => {
+                // Resolve full path so user always knows where the log is
+                let full_path: String = std::path::Path::new(&path)
+                    .canonicalize()
+                    .map(|p| p.display().to_string())
+                    .or_else(|_| {
+                        std::env::current_dir().map(|cwd| cwd.join(&path).display().to_string())
+                    })
+                    .unwrap_or_else(|_| path.clone());
+                let _ = writeln!(
+                    std::io::stderr(),
+                    "[SETUP_PORTAL_DEBUG] Log file: {}",
+                    full_path
+                );
+                let mut w = std::io::BufWriter::new(file_handle);
+                let banner = format!(
+                    "{} === Setup Portal debug log opened: {} ===\n",
+                    timestamp(),
+                    full_path
+                );
+                let _ = w.write_all(banner.as_bytes());
+                let _ = w.flush();
+                *guard = Some(w);
+                return true;
+            }
+            Err(e) => {
+                let _ = writeln!(
+                    std::io::stderr(),
+                    "[SETUP_PORTAL_DEBUG] Failed to open \"{}\": {}",
+                    path,
+                    e
+                );
+                return false;
+            }
+        }
+    }
+    true
+}
+
+fn log_raw(msg: &str) {
+    if !enabled() {
+        return;
+    }
+    if !ensure_open() {
+        return;
+    }
+    let mutex = FILE.get().unwrap();
+    let mut guard = mutex.lock().unwrap();
+    if let Some(ref mut w) = *guard {
+        let _ = w.write_all(msg.as_bytes());
+        let _ = w.write_all(b"\n");
+        let _ = w.flush();
+    }
+}
+
+fn timestamp() -> String {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| format!("{}.{:03}", d.as_secs(), d.subsec_millis()))
+        .unwrap_or_else(|_| "?.???".to_string())
+}
+
+/// Log a line with timestamp. Call from main or setup_portal when debug file is enabled.
+pub fn log(msg: &str) {
+    log_raw(&format!("{} {}", timestamp(), msg));
+}
+
+/// Log screen switch (enter/leave Setup Portal).
+pub fn log_screen(from: &str, to: &str) {
+    log(&format!("SCREEN {} -> {}", from, to));
+}
+
+/// Log an input event (key, mouse, resize).
+pub fn log_input(kind: &str, detail: &str) {
+    log(&format!("INPUT {} {}", kind, detail));
+}
+
+/// Log render state (dims, rects, selected option). Throttled by caller.
+pub fn log_render(msg: &str) {
+    log(&format!("RENDER {}", msg));
+}
+
+/// Log flicker-debug: when we clear and when we finish draw (to correlate with visible flicker).
+/// Writes to debug file when SETUP_PORTAL_DEBUG or SETUP_PORTAL_DEBUG_FILE is set.
+pub fn log_flicker_debug(event: &str, detail: &str) {
+    let msg = format!("FLICKER {} {}", event, detail);
+    log(&msg);
+    // Also to stderr when file debug enabled, so "4r 2> setup-debug.log" captures it
+    if enabled() {
+        let _ = writeln!(std::io::stderr(), "[SETUP_PORTAL_DEBUG] {}", msg);
+    }
+}

package/os-tui/src/io/mod.rs

@@ -0,0 +1,63 @@
+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/os-tui/src/io/protocol.rs

@@ -0,0 +1,14 @@
+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/os-tui/src/io/stdio.rs

@@ -0,0 +1,31 @@
+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/os-tui/src/io/ws.rs

@@ -0,0 +1,25 @@
+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");
+    }
+}