fix(bbs): Fix TUI message posting and add standalone command

- Fix messages not being saved to database (was just logging, never calling db::posts::create)
- Fix 'i' key bug where typing 'i' in input mode didn't add to buffer due to match arm ordering
- Add BBSTuiState::post_message() method for proper database persistence
- Add 11 unit tests for post_message() and key handler behavior
- Add standalone 'osvm bbs tui' command for direct BBS access without research mode

Keyboard shortcuts for new TUI command:
- i: Enter input mode
- Enter: Send message
- Esc/q: Cancel/Quit
- j/k: Scroll posts
- 1-9: Quick-switch boards
- r: Refresh

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: 0xrinegade

src/clparse/bbs.rs

@@ -287,6 +287,36 @@ pub fn build_bbs_command() -> Command {
                         .index(1),
                 ),
         )
+        // Full-screen TUI mode
+        .subcommand(
+            Command::new("tui")
+                .about("Start full-screen TUI interface")
+                .long_about(
+                    "Launch a full-screen terminal user interface for the BBS.\n\
+                    \n\
+                    The TUI provides a rich graphical interface with:\n\
+                    • Board list with quick-switch (1-9 keys)\n\
+                    • Scrollable posts view (j/k or arrow keys)\n\
+                    • Vim-style input mode (press 'i' to type, Enter to send, Esc to cancel)\n\
+                    • Real-time status updates\n\
+                    \n\
+                    Keyboard shortcuts:\n\
+                    • i       - Enter input mode to compose a message\n\
+                    • Enter   - Send message (in input mode)\n\
+                    • Esc     - Cancel input / Exit TUI\n\
+                    • j/k     - Scroll posts up/down\n\
+                    • 1-9     - Quick-switch boards\n\
+                    • r       - Refresh posts\n\
+                    • q       - Quit TUI",
+                )
+                .arg(
+                    Arg::new("board")
+                        .value_name("BOARD")
+                        .help("Initial board to open")
+                        .default_value("GENERAL")
+                        .index(1),
+                ),
+        )
         // Stats and info
         .subcommand(
             Command::new("stats")

src/commands/bbs_handler.rs

@@ -40,6 +40,7 @@ pub async fn handle_bbs_command(matches: &ArgMatches) -> Result<()> {
         Some(("registry", sub_m)) => handle_registry(sub_m).await,
         Some(("server", sub_m)) => handle_server(sub_m).await,
         Some(("interactive", sub_m)) => handle_interactive(sub_m).await,
+        Some(("tui", sub_m)) => handle_tui(sub_m).await,
         Some(("stats", sub_m)) => handle_stats(sub_m).await,
         _ => {
             println!("{}", "Use 'osvm bbs --help' for available commands".yellow());
@@ -736,8 +737,7 @@ async fn handle_interactive(matches: &ArgMatches) -> Result<()> {
     println!("{}", "BBS Interactive Shell".cyan().bold());
     println!("{}", "─".repeat(40));
     println!("  Board: {}", board);
-    println!("\n{} Interactive mode requires a terminal UI.", "!".yellow());
-    println!("  Use 'osvm research <wallet> --tui' and press '5' for BBS tab.");
+    println!("\n{} For full TUI, use: osvm bbs tui", "!".yellow());
     println!("  Or use individual commands:");
     println!("    osvm bbs read {}", board);
     println!("    osvm bbs post {} \"message\"", board);
@@ -746,6 +746,147 @@ async fn handle_interactive(matches: &ArgMatches) -> Result<()> {
     Ok(())
 }
 
+/// Handle full-screen TUI mode
+async fn handle_tui(matches: &ArgMatches) -> Result<()> {
+    use crossterm::{
+        event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyModifiers},
+        execute,
+        terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+    };
+    use ratatui::{backend::CrosstermBackend, Terminal};
+    use std::io;
+    use std::time::Duration;
+
+    let initial_board = matches.get_one::<String>("board").unwrap();
+
+    // Initialize BBS state
+    let mut bbs_state = crate::utils::bbs::tui_widgets::BBSTuiState::new();
+
+    // Connect to database
+    if let Err(e) = bbs_state.connect() {
+        return Err(anyhow!("Failed to connect to BBS database: {}\nRun 'osvm bbs init' first.", e));
+    }
+
+    // Find and select the initial board
+    if let Some(idx) = bbs_state.boards.iter().position(|b| b.name.eq_ignore_ascii_case(initial_board)) {
+        let board_id = bbs_state.boards[idx].id;
+        bbs_state.current_board = Some(board_id);
+        bbs_state.selected_board_index = Some(idx);
+        let _ = bbs_state.load_posts();
+    }
+
+    // Setup terminal
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // Main event loop
+    let result = run_bbs_tui(&mut terminal, &mut bbs_state);
+
+    // Restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    result
+}
+
+/// BBS TUI event loop
+fn run_bbs_tui<B: ratatui::backend::Backend>(
+    terminal: &mut ratatui::Terminal<B>,
+    state: &mut crate::utils::bbs::tui_widgets::BBSTuiState,
+) -> Result<()> {
+    use crossterm::event::{self, Event, KeyCode, KeyModifiers};
+    use std::time::Duration;
+
+    loop {
+        // Draw UI
+        terminal.draw(|f| {
+            crate::utils::bbs::tui_widgets::render_bbs_tab(f, f.area(), state);
+        })?;
+
+        // Handle input
+        if event::poll(Duration::from_millis(100))? {
+            if let Event::Key(key) = event::read()? {
+                // Handle input mode first (when input is active, capture all chars)
+                if state.input_active {
+                    match key.code {
+                        KeyCode::Enter => {
+                            if !state.input_buffer.trim().is_empty() {
+                                if let Err(e) = state.post_message(&state.input_buffer.clone()) {
+                                    state.status_message = format!("Error: {}", e);
+                                } else {
+                                    state.status_message = "Message posted!".to_string();
+                                    let _ = state.load_posts();
+                                }
+                                state.input_buffer.clear();
+                            }
+                            state.input_active = false;
+                        }
+                        KeyCode::Esc => {
+                            state.input_buffer.clear();
+                            state.input_active = false;
+                        }
+                        KeyCode::Backspace => {
+                            state.input_buffer.pop();
+                        }
+                        KeyCode::Char(c) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                            state.input_buffer.push(c);
+                        }
+                        _ => {}
+                    }
+                    continue;
+                }
+
+                // Not in input mode - handle navigation
+                match key.code {
+                    KeyCode::Char('q') | KeyCode::Esc => {
+                        return Ok(());
+                    }
+                    KeyCode::Char('i') => {
+                        state.input_active = true;
+                    }
+                    KeyCode::Char('j') | KeyCode::Down => {
+                        state.scroll_offset = state.scroll_offset.saturating_add(1);
+                    }
+                    KeyCode::Char('k') | KeyCode::Up => {
+                        state.scroll_offset = state.scroll_offset.saturating_sub(1);
+                    }
+                    KeyCode::Char('r') => {
+                        let _ = state.refresh_boards();
+                        if state.current_board.is_some() {
+                            let _ = state.load_posts();
+                        }
+                        state.status_message = "Refreshed".to_string();
+                    }
+                    KeyCode::Char(c @ '1'..='9') => {
+                        let board_idx = c.to_digit(10).unwrap() as usize - 1;
+                        if board_idx < state.boards.len() {
+                            let board_id = state.boards[board_idx].id;
+                            let board_name = state.boards[board_idx].name.clone();
+                            state.current_board = Some(board_id);
+                            state.selected_board_index = Some(board_idx);
+                            let _ = state.load_posts();
+                            state.scroll_offset = 0;
+                            state.status_message = format!("Switched to: {}", board_name);
+                        }
+                    }
+                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                        return Ok(());
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+}
+
 /// Handle stats command
 async fn handle_stats(matches: &ArgMatches) -> Result<()> {
     let mut conn = db_err(db::establish_connection())?;

src/utils/bbs/tui_widgets.rs

@@ -413,4 +413,102 @@ mod tests {
         assert!(!state.input_active);
         assert_eq!(state.selected_board_index, Some(0));
     }
+
+    // =========================================================================
+    // Key Handler Simulation Tests
+    // These test the logic that should be implemented in app.rs event_loop
+    // to prevent regression of the "can't type 'i' in input mode" bug
+    // =========================================================================
+
+    /// Simulates pressing 'i' key when NOT in input mode
+    /// Expected: input_active becomes true, buffer unchanged
+    fn simulate_i_key_not_in_input(state: &mut BBSTuiState) {
+        if !state.input_active {
+            state.input_active = true;
+        }
+    }
+
+    /// Simulates pressing any char key when IN input mode
+    /// Expected: char is added to buffer
+    fn simulate_char_key_in_input(state: &mut BBSTuiState, c: char) {
+        if state.input_active {
+            state.input_buffer.push(c);
+        }
+    }
+
+    #[test]
+    fn test_key_i_activates_input_mode() {
+        let mut state = BBSTuiState::new();
+        assert!(!state.input_active, "Should start with input inactive");
+
+        // Press 'i' to activate
+        simulate_i_key_not_in_input(&mut state);
+
+        assert!(state.input_active, "'i' should activate input mode");
+        assert!(state.input_buffer.is_empty(), "Buffer should remain empty on activation");
+    }
+
+    #[test]
+    fn test_key_i_in_input_mode_adds_to_buffer() {
+        let mut state = BBSTuiState::new();
+
+        // Activate input mode first
+        state.input_active = true;
+
+        // Now press 'i' while in input mode - should ADD 'i' to buffer
+        simulate_char_key_in_input(&mut state, 'i');
+
+        assert!(state.input_active, "Should remain in input mode");
+        assert_eq!(state.input_buffer, "i", "'i' should be added to buffer");
+
+        // Press more characters including 'i' again
+        simulate_char_key_in_input(&mut state, ' ');
+        simulate_char_key_in_input(&mut state, 'l');
+        simulate_char_key_in_input(&mut state, 'i');
+        simulate_char_key_in_input(&mut state, 'k');
+        simulate_char_key_in_input(&mut state, 'e');
+
+        assert_eq!(state.input_buffer, "i like", "All chars including 'i' should be in buffer");
+    }
+
+    #[test]
+    fn test_typing_word_with_i_in_input_mode() {
+        let mut state = BBSTuiState::new();
+        state.input_active = true;
+
+        // Type "this is a test" which has multiple 'i' characters
+        for c in "this is a test".chars() {
+            simulate_char_key_in_input(&mut state, c);
+        }
+
+        assert_eq!(state.input_buffer, "this is a test",
+            "Should be able to type words with 'i' without losing characters");
+    }
+
+    #[test]
+    fn test_input_mode_toggle_sequence() {
+        let mut state = BBSTuiState::new();
+
+        // 1. Start inactive
+        assert!(!state.input_active);
+
+        // 2. Press 'i' to activate
+        simulate_i_key_not_in_input(&mut state);
+        assert!(state.input_active);
+        assert!(state.input_buffer.is_empty());
+
+        // 3. Type "hi"
+        simulate_char_key_in_input(&mut state, 'h');
+        simulate_char_key_in_input(&mut state, 'i');
+        assert_eq!(state.input_buffer, "hi");
+
+        // 4. Deactivate (simulate Esc)
+        state.input_active = false;
+        state.input_buffer.clear();
+
+        // 5. Press 'i' again to reactivate
+        simulate_i_key_not_in_input(&mut state);
+        assert!(state.input_active);
+        assert!(state.input_buffer.is_empty());
+    }
 }