v4.0.7: finish the Phase 1 boundary with a command shell

The terminal command line moves to client::shell: a typed line becomes a core Command or an adapter action (connect, login, register, set-credential, host maintenance). ClientCore loses submit_line and the last TUI-shaped effects (Interactive, SetPrompt, ListHosts, ForgetHost, AnimateRoulette); the adapter animates roulette from the Result view.

Adds forget-login, which drops the stored credential for the pinned key and keeps trust, distinct from logout (session only) and forget-host (trust too).

7 files changed, 332 insertions, 253 deletions

diff --git a/src/bin/client/repl.rs b/src/bin/client/repl.rs
index bc4238d..cfdcdd5 100644
--- a/src/bin/client/repl.rs
+++ b/src/bin/client/repl.rs
@@ -13,12 +13,14 @@ use crossterm::{
 
 use sha2::{Digest, Sha256};
 
-use zagan_bet::client::core::{ClientCore, Effect, InteractiveCommand};
-use zagan_bet::client::input::{game_input, GameInput, Input, Key, Editor};
+use zagan_bet::client::core::{ClientCore, Effect};
+use zagan_bet::client::input::{game_input, Editor, GameInput, Input, Key};
+use zagan_bet::client::shell::{self, Shell};
+use zagan_bet::client::view::{RoulettePhase, View};
 use zagan_bet::client::database;
 use zagan_bet::client::ui::{
-    display_width, format_pong, host_lines, input_cursor_column, lines_to_move_up,
-    terminal_size_warning, visual_line_count, MIN_COLUMNS, MIN_ROWS,
+    display_width, format_pong, help_lines, host_lines, input_cursor_column,
+    lines_to_move_up, terminal_size_warning, visual_line_count, MIN_COLUMNS, MIN_ROWS,
 };
 use zagan_bet::protocol::io_failure_message;
 use zagan_bet::roulette::{WHEEL, color as roulette_color};
@@ -42,6 +44,8 @@ pub struct ClientState {
     terminal_size: (u16, u16),
     /// Size we already warned about, so a resize does not spam the transcript.
     size_warned: Option<(u16, u16)>,
+    /// Last roulette result the wheel animation ran for.
+    last_roulette: Option<u8>,
 }
 
 impl ClientState {
@@ -67,6 +71,7 @@ impl ClientState {
             prompt_text: String::new(),
             terminal_size: crossterm::terminal::size().unwrap_or((MIN_COLUMNS, MIN_ROWS)),
             size_warned: None,
+            last_roulette: None,
         })
     }
 
@@ -129,7 +134,7 @@ impl ClientState {
                                 } else {
                                     match self.editor.handle(key) {
                                         Input::Quit => vec![Effect::Quit],
-                                        Input::Submit(line) => self.core.submit_line(&line),
+                                        Input::Submit(line) => self.submit_line(&line),
                                         Input::Print(lines) => vec![Effect::Print(lines)],
                                         Input::Prompt | Input::None => Vec::new(),
                                     }
@@ -233,17 +238,26 @@ impl ClientState {
                     }
                 }
                 Effect::Render(view) => {
+                    if let View::Roulette(roulette) = &view {
+                        if roulette.phase == RoulettePhase::Result {
+                            if let Some(number) = roulette.number {
+                                if self.last_roulette != Some(number) {
+                                    self.animate_wheel(number);
+                                    self.last_roulette = Some(number);
+                                    while crossterm::event::poll(std::time::Duration::ZERO)
+                                        .unwrap_or(false)
+                                    {
+                                        let _ = crossterm::event::read();
+                                    }
+                                }
+                            }
+                        } else {
+                            self.last_roulette = None;
+                        }
+                    }
                     let lines = zagan_bet::client::tui::render_view(&view);
                     self.draw_region(&lines);
                 }
-                Effect::AnimateRoulette { winning, view } => {
-                    self.animate_wheel(winning);
-                    let lines = zagan_bet::client::tui::render_view(&view);
-                    self.draw_region(&lines);
-                    while crossterm::event::poll(std::time::Duration::ZERO).unwrap_or(false) {
-                        let _ = crossterm::event::read();
-                    }
-                }
                 Effect::ClearRegion => self.clear_region(),
                 Effect::SendLine(line) => {
                     let is_ping = line == "PING";
@@ -269,37 +283,11 @@ impl ClientState {
                         return true;
                     }
                 }
-                Effect::Interactive(command) => {
-                    self.commit_prompt_line();
-                    self.run_interactive(command);
-                }
                 Effect::Disconnect => {
                     self.stream = None;
+                    self.core.reset_after_disconnect();
                     self.clear_region();
                 }
-                Effect::ListHosts => {
-                    self.commit_prompt_line();
-                    self.list_hosts();
-                }
-                Effect::ForgetHost(target) => {
-                    self.commit_prompt_line();
-                    match database::forget_host(&self.conn, &target) {
-                        Ok(outcome) if outcome.credentials_removed => println!(
-                            "Cleared trust and stored credentials for {}.",
-                            target
-                        ),
-                        Ok(outcome) => {
-                            println!("Cleared trust for {}.", target);
-                            if !outcome.siblings.is_empty() {
-                                println!(
-                                    "Stored credentials kept: this server is still reachable as {}.",
-                                    outcome.siblings.join(", ")
-                                );
-                            }
-                        }
-                        Err(error) => println!("Failed to forget host: {}", error),
-                    }
-                }
                 Effect::Quit => {
                     let had_board = self.game_lines > 0;
                     self.clear_region();
@@ -545,28 +533,112 @@ impl ClientState {
         }
     }
 
-    fn run_interactive(&mut self, command: InteractiveCommand) {
-        match command {
-            InteractiveCommand::Login => self.do_login(),
-            InteractiveCommand::Register => self.do_register(),
-            InteractiveCommand::SetCred => self.do_setcred(),
-            InteractiveCommand::Connect(target) => {
-                if self.stream.is_some() {
-                    println!("Already connected. Disconnect first.");
+    /// Run one command line from the prompt.
+    fn submit_line(&mut self, line: &str) -> Vec<Effect> {
+        match shell::parse(line) {
+            Shell::Run(command) => self.core.command(command),
+            Shell::Login => {
+                self.do_login();
+                Vec::new()
+            }
+            Shell::Register => {
+                self.do_register();
+                Vec::new()
+            }
+            Shell::SetCred => {
+                self.do_setcred();
+                Vec::new()
+            }
+            Shell::Connect(target) => {
+                self.do_connect(target);
+                Vec::new()
+            }
+            Shell::Disconnect => {
+                self.stream = None;
+                self.core.reset_after_disconnect();
+                vec![
+                    Effect::ClearRegion,
+                    Effect::Print(vec!["Disconnected".to_string()]),
+                ]
+            }
+            Shell::Hosts => {
+                self.list_hosts();
+                Vec::new()
+            }
+            Shell::ForgetHost(target) => {
+                self.forget_host(target);
+                Vec::new()
+            }
+            Shell::ForgetLogin(target) => {
+                self.forget_login(target);
+                Vec::new()
+            }
+            Shell::Help => vec![Effect::Print(help_lines())],
+            Shell::Quit => vec![Effect::Quit],
+            Shell::Empty => Vec::new(),
+            Shell::Usage(message) => vec![Effect::Print(vec![message])],
+        }
+    }
+
+    fn do_connect(&mut self, target: Option<String>) {
+        if self.stream.is_some() {
+            println!("Already connected. Disconnect first.");
+            return;
+        }
+        let addr = match target {
+            Some(target) => self.normalize_addr(target),
+            None => match &self.addr {
+                Some(addr) => addr.clone(),
+                None => {
+                    println!("No host specified. Usage: connect <ip>:<port>");
                     return;
                 }
-                let addr = match target {
-                    Some(target) => self.normalize_addr(target),
-                    None => match &self.addr {
-                        Some(addr) => addr.clone(),
-                        None => {
-                            println!("No host specified. Usage: connect <ip>:<port>");
-                            return;
-                        }
-                    },
-                };
-                self.connect_to(&addr);
+            },
+        };
+        self.connect_to(&addr);
+    }
+
+    /// Drop the stored login for one server, keeping the pinned key.
+    fn forget_login(&mut self, target: Option<String>) {
+        let Some(host) = target.or_else(|| self.addr.clone()) else {
+            println!("Usage: forget-login [ip:port] (or connect first)");
+            return;
+        };
+        let Some(identity) = database::get_fingerprint(&self.conn, &host) else {
+            println!("No trusted server is remembered as {}.", host);
+            return;
+        };
+        match database::forget_credentials(&self.conn, &identity) {
+            Ok(true) => println!(
+                "Forgot the saved login for server {} ({}). Trust is unchanged.",
+                short_fingerprint(&identity),
+                host
+            ),
+            Ok(false) => println!("No saved login for server {} ({}).", short_fingerprint(&identity), host),
+            Err(error) => println!("Failed to forget the saved login: {}", error),
+        }
+    }
+
+    fn forget_host(&mut self, target: Option<String>) {
+        let Some(target) = target.or_else(|| self.addr.clone()) else {
+            println!("Usage: forget-host <ip>:<port> (or connect first)");
+            return;
+        };
+        match database::forget_host(&self.conn, &target) {
+            Ok(outcome) if outcome.credentials_removed => println!(
+                "Cleared trust and stored credentials for {}.",
+                target
+            ),
+            Ok(outcome) => {
+                println!("Cleared trust for {}.", target);
+                if !outcome.siblings.is_empty() {
+                    println!(
+                        "Stored credentials kept: this server is still reachable as {}.",
+                        outcome.siblings.join(", ")
+                    );
+                }
             }
+            Err(error) => println!("Failed to forget host: {}", error),
         }
     }
 
diff --git a/src/client/core.rs b/src/client/core.rs
index 280eb77..21c1cb2 100644
--- a/src/client/core.rs
+++ b/src/client/core.rs
@@ -6,20 +6,13 @@ use crate::client::games::response::{
 use crate::client::view::{
     BlackjackView, Command, CrashView, HistoryView, LobbyView, RouletteView, SlotsView, View,
 };
-use crate::client::ui::{help_lines, history_lines, parse_bet_arg};
+use crate::client::ui::{game_lines, history_lines};
 use crate::crash::{CrashState, multiplier_at};
 use crate::history::{PlayRecord, MAX_HISTORY};
 use crate::roulette::{BetTarget, Bets};
 use std::time::{Duration, Instant};
 
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InteractiveCommand {
-    Login,
-    Register,
-    SetCred,
-    Connect(Option<String>),
-}
 
 /// High-level actions produced by the client core. The terminal adapter is
 /// responsible for turning these into crossterm calls and network writes.
@@ -29,20 +22,12 @@ pub enum Effect {
     Print(Vec<String>),
     /// Draw the current view in the board region.
     Render(View),
-    /// Run the roulette wheel animation, then draw the final view.
-    AnimateRoulette { winning: u8, view: View },
     /// Remove the game board region.
     ClearRegion,
     /// Send one protocol line and feed the reply to `handle_reply`.
     SendLine(String),
-    /// Delegate an interactive prompt flow to the terminal adapter.
-    Interactive(InteractiveCommand),
     /// Drop the connection.
     Disconnect,
-    /// Let the adapter read the host database.
-    ListHosts,
-    /// Let the adapter delete a host from the database.
-    ForgetHost(String),
     /// Leave the program.
     Quit,
 }
@@ -175,12 +160,8 @@ impl ClientCore {
             Some(Pending::RouletteSpin) => match parse_roulette_response(reply) {
                 Ok(result) => {
                     self.balance = Some(result.balance);
-                    let winning = result.number;
                     self.game.apply_roulette_result(result);
-                    let Some(view) = self.view() else {
-                        return Vec::new();
-                    };
-                    vec![Effect::AnimateRoulette { winning, view }]
+                    self.board_effects()
                 }
                 Err(message) => {
                     self.game.set_error(message);
@@ -331,22 +312,41 @@ impl ClientCore {
 
         match command {
             Command::Login { user, credential } => {
-        if !self.connected {
-            return print_line("Not connected. Use 'connect <ip>:<port>' first.");
-        }
-        self.login_error = None;
-        self.pending = Some(Pending::Login { user: user.clone() });
-        vec![Effect::SendLine(format!("AUTH {user} {credential}"))]
-    }
-    Command::Register { user, credential } => {
-        if !self.connected {
-            return print_line("Not connected. Use 'connect <ip>:<port>' first.");
-        }
-        self.login_error = None;
-        self.pending = Some(Pending::Register);
-        vec![Effect::SendLine(format!("REGISTER {user} {credential}"))]
-    }
-    Command::Play { game, bet } => self.play_game(&game, bet),
+                if !self.connected {
+                    return print_line("Not connected. Use 'connect <ip>:<port>' first.");
+                }
+                self.login_error = None;
+                self.pending = Some(Pending::Login { user: user.clone() });
+                vec![Effect::SendLine(format!("AUTH {user} {credential}"))]
+            }
+            Command::Register { user, credential } => {
+                if !self.connected {
+                    return print_line("Not connected. Use 'connect <ip>:<port>' first.");
+                }
+                self.login_error = None;
+                self.pending = Some(Pending::Register);
+                vec![Effect::SendLine(format!("REGISTER {user} {credential}"))]
+            }
+            Command::Games => vec![Effect::Print(game_lines(&self.games()))],
+            Command::Ping => {
+                if !self.connected {
+                    return print_line("Not connected. Use 'connect <ip>:<port>' first.");
+                }
+                self.pending = Some(Pending::Ping);
+                vec![Effect::SendLine("PING".to_string())]
+            }
+            Command::Echo(message) => {
+                if !self.connected {
+                    return print_line("Not connected. Use 'connect <ip>:<port>' first.");
+                }
+                if message.trim().is_empty() {
+                    return print_line("Usage: send <message>");
+                }
+                self.pending = Some(Pending::Echo);
+                vec![Effect::SendLine(message)]
+            }
+            Command::Info => self.info_effects(),
+            Command::Play { game, bet } => self.play_game(&game, bet),
             Command::History { limit } => self.load_history(limit),
             Command::ShowLobby => {
                 self.screen = Screen::Lobby;
@@ -672,106 +672,6 @@ impl ClientCore {
         vec![Effect::SendLine(format!("CRASH_CASHOUT {session}"))]
     }
 
-    /// Run one command line. The interactive frontend owns the buffer and the
-    /// history; the core only sees the finished line.
-    pub fn submit_line(&mut self, line: &str) -> Vec<Effect> {
-        let line = line.trim().to_string();
-        if line.is_empty() {
-            return Vec::new();
-        }
-
-        let parts: Vec<&str> = line.splitn(3, ' ').collect();
-        match parts[0] {
-            "play" => self.cmd_play(&parts),
-            "games" => self.available_games(None),
-            "help" => vec![Effect::Print(help_lines())],
-            "connect" => {
-                if self.connected {
-                    print_line("Already connected. Disconnect first.")
-                } else {
-                    let target = parts.get(1).map(|value| value.to_string());
-                    vec![Effect::Interactive(InteractiveCommand::Connect(target))]
-                }
-            }
-            "login" => {
-                if !self.connected {
-                    print_line("Not connected. Use 'connect <ip>:<port>' first.")
-                } else if self.logged_in.is_some() {
-                    print_line(format!(
-                        "Already logged in as {}",
-                        self.logged_in.as_deref().unwrap_or("?")
-                    ))
-                } else {
-                    vec![Effect::Interactive(InteractiveCommand::Login)]
-                }
-            }
-            "register" => {
-                if !self.connected {
-                    print_line("Not connected. Use 'connect <ip>:<port>' first.")
-                } else {
-                    vec![Effect::Interactive(InteractiveCommand::Register)]
-                }
-            }
-            "setcred" => {
-                if self.host.is_none() {
-                    print_line("No host connected. Use 'connect <ip>:<port>' first.")
-                } else {
-                    vec![Effect::Interactive(InteractiveCommand::SetCred)]
-                }
-            }
-            "logout" => {
-                self.logged_in = None;
-                print_line("Logged out")
-            }
-            "disconnect" => {
-                self.connected = false;
-                self.logged_in = None;
-                self.pending = None;
-                self.crash_started = None;
-                self.game.end_game();
-                vec![
-                    Effect::ClearRegion,
-                    Effect::Disconnect,
-                    Effect::Print(vec!["Disconnected".to_string()]),
-                ]
-            }
-            "ping" => {
-                if !self.connected {
-                    print_line("Not connected. Use 'connect <ip>:<port>' first.")
-                } else {
-                    self.pending = Some(Pending::Ping);
-                    vec![Effect::SendLine("PING".to_string())]
-                }
-            }
-            "send" => {
-                if !self.connected {
-                    print_line("Not connected. Use 'connect <ip>:<port>' first.")
-                } else if parts.len() < 2 {
-                    print_line("Usage: send <message>")
-                } else {
-                    let message = parts[1..].join(" ");
-                    self.pending = Some(Pending::Echo);
-                    vec![Effect::SendLine(message)]
-                }
-            }
-            "info" => self.cmd_info(),
-            "history" => self.cmd_history(&parts),
-            "hosts" => vec![Effect::ListHosts],
-            "forget-host" => {
-                let target = parts
-                    .get(1)
-                    .map(|value| value.to_string())
-                    .or_else(|| self.host.clone());
-                match target {
-                    Some(target) => vec![Effect::ForgetHost(target)],
-                    None => print_line("Usage: forget-host <ip>:<port> (or connect first)"),
-                }
-            }
-            "quit" => vec![Effect::Quit],
-            _ => vec![Effect::Print(help_lines())],
-        }
-    }
-
     fn play_game(&mut self, game_type: &str, bet: Option<u64>) -> Vec<Effect> {
         if !self.connected {
             return print_line("Not connected. Use 'connect <ip>:<port>' first.");
@@ -822,56 +722,7 @@ impl ClientCore {
         vec![Effect::SendLine(request)]
     }
 
-    fn cmd_play(&mut self, parts: &[&str]) -> Vec<Effect> {
-        if !self.connected {
-            return print_line("Not connected. Use 'connect <ip>:<port>' first.");
-        }
-        if self.logged_in.is_none() {
-            return print_line("Not logged in. Use 'login' first.");
-        }
-        if parts.len() < 2 {
-            return self.available_games(Some("Usage: play <game> [bet]"));
-        }
-
-        let bet = match parts.get(2) {
-            Some(raw) => match parse_bet_arg(raw) {
-                Ok(bet) => Some(bet),
-                Err(message) => return print_line(message),
-            },
-            None => None,
-        };
-
-        self.command(Command::Play {
-            game: parts[1].to_string(),
-            bet,
-        })
-    }
-
-    fn available_games(&self, usage: Option<&str>) -> Vec<Effect> {
-        let mut lines = vec!["Available games:".to_string()];
-        for (game_type, name) in self.game.get_available_games() {
-            lines.push(format!("  - {} ({})", game_type, name));
-        }
-        if let Some(usage) = usage {
-            lines.push(String::new());
-            lines.push(usage.to_string());
-        }
-        vec![Effect::Print(lines)]
-    }
-
-    fn cmd_history(&mut self, parts: &[&str]) -> Vec<Effect> {
-        let limit = match parts.get(1) {
-            Some(raw) => match raw.parse::<u32>() {
-                Ok(count) => count,
-                Err(_) => return print_line(format!("Usage: history [1-{MAX_HISTORY}]")),
-            },
-            None => crate::history::DEFAULT_HISTORY,
-        };
-
-        self.command(Command::History { limit })
-    }
-
-    fn cmd_info(&mut self) -> Vec<Effect> {
+    fn info_effects(&mut self) -> Vec<Effect> {
         if !self.connected {
             return print_line("Not connected to any host.");
         }
@@ -895,7 +746,24 @@ impl ClientCore {
         effects
     }
 
-    /// Snapshot of the current screen for a frontend to draw.
+    /// The games a frontend can offer.
+    pub fn games(&self) -> Vec<(String, String)> {
+        self.game
+            .get_available_games()
+            .into_iter()
+            .map(|(game, name)| (game.to_string(), name.to_string()))
+            .collect()
+    }
+
+    /// Reset connection-dependent state after the adapter closed the socket.
+    ///
+    /// The transport belongs to the frontend, so it tells the core when the
+    /// link is gone. What to say about it is the frontend's business.
+    pub fn reset_after_disconnect(&mut self) {
+        self.set_connected(false);
+        self.game.end_game();
+    }
+
     pub fn view(&self) -> Option<View> {
         if let Some(state) = self.game.get_current_state() {
             return Some(match state.game_type.as_str() {
@@ -915,12 +783,7 @@ impl ClientCore {
                 connected: self.connected,
                 user: self.logged_in.clone(),
                 balance: self.balance,
-                games: self
-                    .game
-                    .get_available_games()
-                    .into_iter()
-                    .map(|(game, name)| (game.to_string(), name.to_string()))
-                    .collect(),
+                games: self.games(),
                 login_error: self.login_error.clone(),
             }),
         })
diff --git a/src/client/database.rs b/src/client/database.rs
index c4601b5..40ee8b4 100644
--- a/src/client/database.rs
+++ b/src/client/database.rs
@@ -151,6 +151,21 @@ pub fn forget_host(conn: &Connection, host: &str) -> Result<ForgetOutcome, rusql
     })
 }
 
+/// Forget the saved login for a server identity ("forget saved login").
+///
+/// Trust is untouched: the pinned key stays in `hosts`, so the next connection
+/// only asks for a password. Returns whether a credential was actually stored.
+pub fn forget_credentials(
+    conn: &Connection,
+    fingerprint: &str,
+) -> Result<bool, rusqlite::Error> {
+    let removed = conn.execute(
+        "DELETE FROM credentials WHERE fingerprint = ?1",
+        [fingerprint],
+    )?;
+    Ok(removed > 0)
+}
+
 /// List all remembered hosts with their fingerprints.
 pub fn get_all_hosts(conn: &Connection) -> Vec<(String, Option<String>)> {
     let mut stmt = conn
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 1d79d97..e3bc1b3 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -3,6 +3,7 @@ pub mod database;
 pub mod games;
 pub mod input;
 pub mod paths;
+pub mod shell;
 pub mod transport;
 pub mod tui;
 pub mod ui;
diff --git a/src/client/shell.rs b/src/client/shell.rs
new file mode 100644
index 0000000..73843c8
--- /dev/null
+++ b/src/client/shell.rs
@@ -0,0 +1,110 @@
+//! Parser for the terminal's command line.
+//!
+//! The core speaks `Command`; this module turns one typed line into either a
+//! core command or an action only an interactive frontend can perform
+//! (connecting, prompting for a password, listing hosts).
+
+use crate::client::ui::parse_bet_arg;
+use crate::client::view::Command;
+use crate::history::{DEFAULT_HISTORY, MAX_HISTORY};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Shell {
+    /// A command the core can run on its own.
+    Run(Command),
+    Login,
+    Register,
+    SetCred,
+    Connect(Option<String>),
+    Disconnect,
+    Hosts,
+    ForgetHost(Option<String>),
+    ForgetLogin(Option<String>),
+    Help,
+    Quit,
+    Empty,
+    Usage(String),
+}
+
+/// Split off the first whitespace-delimited word.
+///
+/// The remainder keeps its internal spacing (so `send` can echo a message
+/// verbatim) but loses the separator run before it.
+fn split_word(line: &str) -> (&str, &str) {
+    match line.find(char::is_whitespace) {
+        Some(index) => (&line[..index], line[index..].trim_start()),
+        None => (line, ""),
+    }
+}
+
+pub fn parse(line: &str) -> Shell {
+    let line = line.trim();
+    if line.is_empty() {
+        return Shell::Empty;
+    }
+
+    let (word, rest) = split_word(line);
+    match word {
+        "play" => {
+            let (game, bet) = split_word(rest);
+            if game.is_empty() {
+                return Shell::Usage("Usage: play <game> [bet]".to_string());
+            }
+            let bet = if bet.is_empty() {
+                None
+            } else {
+                match parse_bet_arg(bet) {
+                    Ok(bet) => Some(bet),
+                    Err(message) => return Shell::Usage(message),
+                }
+            };
+            Shell::Run(Command::Play {
+                game: game.to_string(),
+                bet,
+            })
+        }
+        "history" => {
+            let (raw, _) = split_word(rest);
+            let limit = if raw.is_empty() {
+                DEFAULT_HISTORY
+            } else {
+                match raw.parse::<u32>() {
+                    Ok(count) if (1..=MAX_HISTORY).contains(&count) => count,
+                    _ => return Shell::Usage(format!("Usage: history [1-{MAX_HISTORY}]")),
+                }
+            };
+            Shell::Run(Command::History { limit })
+        }
+        "games" => Shell::Run(Command::Games),
+        "logout" => Shell::Run(Command::Logout),
+        "ping" => Shell::Run(Command::Ping),
+        "send" => {
+            if rest.is_empty() {
+                Shell::Usage("Usage: send <message>".to_string())
+            } else {
+                Shell::Run(Command::Echo(rest.to_string()))
+            }
+        }
+        "info" => Shell::Run(Command::Info),
+        "help" => Shell::Help,
+        "connect" => Shell::Connect(optional_word(rest)),
+        "login" => Shell::Login,
+        "register" => Shell::Register,
+        "setcred" => Shell::SetCred,
+        "disconnect" => Shell::Disconnect,
+        "hosts" => Shell::Hosts,
+        "forget-host" => Shell::ForgetHost(optional_word(rest)),
+        "forget-login" => Shell::ForgetLogin(optional_word(rest)),
+        "quit" => Shell::Quit,
+        _ => Shell::Help,
+    }
+}
+
+fn optional_word(rest: &str) -> Option<String> {
+    let (word, _) = split_word(rest);
+    if word.is_empty() {
+        None
+    } else {
+        Some(word.to_string())
+    }
+}
diff --git a/src/client/ui.rs b/src/client/ui.rs
index bb5b55f..7439e0f 100644
--- a/src/client/ui.rs
+++ b/src/client/ui.rs
@@ -76,6 +76,11 @@ const COMMANDS: &[CommandHelp] = &[
         description: "clear trust for one address (credentials stay while the key is in use)",
     },
     CommandHelp {
+        name: "forget-login",
+        usage: "forget-login [ip:port]",
+        description: "forget the saved login (trust is kept)",
+    },
+    CommandHelp {
         name: "hosts",
         usage: "hosts",
         description: "list remembered hosts",
@@ -272,6 +277,15 @@ pub fn terminal_size_warning(columns: u16, rows: u16) -> Option<String> {
     ))
 }
 
+/// List of games for the terminal's `games` command.
+pub fn game_lines(games: &[(String, String)]) -> Vec<String> {
+    let mut lines = vec!["Available games:".to_string()];
+    for (game, name) in games {
+        lines.push(format!("  - {game} ({name})"));
+    }
+    lines
+}
+
 /// One line per settled play, newest first.
 pub fn history_lines(records: &[crate::history::PlayRecord]) -> Vec<String> {
     if records.is_empty() {
diff --git a/src/client/view.rs b/src/client/view.rs
index 9443726..d2ccadb 100644
--- a/src/client/view.rs
+++ b/src/client/view.rs
@@ -274,6 +274,10 @@ pub enum View {
 pub enum Command {
     /// The credential is already hashed by the frontend.
     Login { user: String, credential: String },
+    Games,
+    Ping,
+    Echo(String),
+    Info,
     Register { user: String, credential: String },
     Play { game: String, bet: Option<u64> },
     History { limit: u32 },