4runr-os 2.10.39 → 2.10.41

package/mk3-tui/src/debug_log.rs

@@ -1,124 +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
-//!   mk3-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);
-    }
-}
+//! 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
+//!   mk3-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/mk3-tui/src/io/mod.rs

@@ -1,66 +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(())
-    }
-}
-
+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/mk3-tui/src/io/protocol.rs

@@ -1,15 +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>,
-}
-
+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/mk3-tui/src/io/stdio.rs

@@ -1,32 +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));
-        }
-    }
-}
-
+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/mk3-tui/src/io/ws.rs

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