use std::io::Write as _;
use crossterm::event::{self, Event};
use crossterm::terminal::{
EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
};
use os::Credentials;
use os::unix::unix_os::UnixOs;
const BOX_WIDTH: usize = 32;
const PLACEHOLDER: &str = "enter password here";
const FALLBACK_COLUMNS: usize = 80;
const MINIMUM_COLUMNS: usize = 20;
fn visible(text: &str) -> usize {
let mut count = 0;
let mut rest = text;
while let Some(start) = rest.find('\x1b') {
count += rest[..start].chars().count();
match rest[start..].find(|ch: char| ch.is_ascii_alphabetic()) {
Some(end) => rest = &rest[start + end + 1..],
None => break,
}
}
count + rest.chars().count()
}
struct LoginScreen {
os_name: String,
#[allow(dead_code)]
host: String,
user: String,
input: String,
failure: Option<String>,
hint: Option<String>,
}
impl LoginScreen {
fn new(os_name: &str, host: &str, user: &str) -> Self {
Self {
os_name: os_name.to_owned(),
host: host.to_owned(),
user: user.to_owned(),
input: String::new(),
failure: None,
hint: None,
}
}
fn frame_with_width(&self, columns: usize) -> String {
let columns = columns.max(MINIMUM_COLUMNS);
let center = |text: &str| {
let pad = columns.saturating_sub(visible(text)) / 2;
format!("{}{text}\x1b[K", " ".repeat(pad))
};
let mut f = String::new();
f.push_str("\x1b[H");
let title = self.os_name.to_uppercase();
let title_width = title.chars().count();
if title_width + 10 <= columns {
let rule = "═".repeat(title_width + 6);
let padded = format!("{title:^width$}", width = title_width + 6);
f.push_str(¢er(&format!("╔{rule}╗")));
f.push_str("\r\n");
f.push_str(¢er(&format!("║\x1b[7m{padded}\x1b[0m║")));
f.push_str("\r\n");
f.push_str(¢er(&format!("╚{rule}╝")));
} else {
f.push_str(¢er(&format!("\x1b[7m{title}\x1b[0m")));
}
f.push_str("\r\n");
f.push_str("\x1b[K\r\n");
f.push_str(¢er(&self.user));
f.push_str("\r\n\x1b[K\r\n");
let box_inner = BOX_WIDTH.min(columns.saturating_sub(8)).max(6);
let inner = if self.input.is_empty() {
if PLACEHOLDER.len() <= box_inner {
format!(
"\x1b[2m{PLACEHOLDER}\x1b[0m{}",
" ".repeat(box_inner - PLACEHOLDER.len())
)
} else {
" ".repeat(box_inner)
}
} else {
let dots: String = self.input.chars().take(box_inner).map(|_| '•').collect();
format!("{dots}{}", " ".repeat(box_inner - dots.chars().count()))
};
let edge = "─".repeat(box_inner + 2);
f.push_str(¢er(&format!("┌{edge}┐")));
f.push_str("\r\n");
f.push_str(¢er(&format!("│ {inner} │")));
f.push_str("\r\n");
f.push_str(¢er(&format!("└{edge}┘")));
f.push_str("\r\n");
if let Some(message) = &self.failure {
f.push_str("\r\n");
f.push_str(¢er(&format!("\x1b[2m{message}\x1b[0m")));
f.push_str("\r\n");
if let Some(hint) = &self.hint {
let prefix = "Hint: ";
let mut line = String::new();
for word in hint.split_whitespace() {
let candidate = if line.is_empty() {
format!("{prefix}{word}")
} else {
format!("{line} {word}")
};
if visible(&candidate) > columns && !line.is_empty() {
f.push_str(¢er(&format!("\x1b[2m{line}\x1b[0m")));
f.push_str("\r\n");
line = format!("{prefix}{word}");
} else {
line = candidate;
}
}
if !line.is_empty() {
f.push_str(¢er(&format!("\x1b[2m{line}\x1b[0m")));
f.push_str("\r\n");
}
}
}
f
}
fn cursor_position(&self, columns: usize) -> (u16, u16) {
let columns = columns.max(MINIMUM_COLUMNS);
let title_width = self.os_name.to_uppercase().chars().count();
let banner_rows: u16 = if title_width + 10 <= columns { 3 } else { 1 };
let row: u16 = banner_rows + 1 + 1 + 1 + 2;
let box_inner = BOX_WIDTH.min(columns.saturating_sub(8)).max(6) as u16;
let box_width = box_inner + 4;
let pad = (columns as u16).saturating_sub(box_width) / 2;
let col: u16 = pad + 3 + (self.input.chars().count() as u16).min(box_inner);
(row, col)
}
#[allow(dead_code)]
fn frame(&self) -> String {
let columns = crossterm::terminal::size()
.map(|(cols, _)| usize::from(cols))
.unwrap_or(FALLBACK_COLUMNS);
self.frame_with_width(columns)
}
}
pub fn run(
unix: &UnixOs,
display_name: &str,
host: &str,
user: &str,
) -> Result<Credentials, String> {
let mut state = LoginScreen::new(display_name, host, user);
state.hint = unix
.users()
.by_name(user)
.and_then(|account| account.hint().map(str::to_owned));
let _raw = enable_raw_mode();
let _ = crossterm::execute!(std::io::stdout(), EnterAlternateScreen);
let mut columns = crossterm::terminal::size()
.map(|(c, _)| usize::from(c))
.unwrap_or(FALLBACK_COLUMNS);
let mut frame = state.frame_with_width(columns);
print!("{frame}");
let (row, col) = state.cursor_position(columns);
print!("\x1b[{row};{col}H\x1b[?25h");
let _ = std::io::stdout().flush();
loop {
match event::read() {
Ok(Event::Key(key)) => match crate::host::translate_key(&key) {
Some(engine::KeyEvent {
key: engine::Key::Character,
character: Some('c' | 'd'),
ctrl: true,
..
}) => break,
Some(engine::KeyEvent {
key: engine::Key::Character,
character: Some(ch),
ctrl: false,
..
}) => {
state.input.push(ch);
state.failure = None;
}
Some(engine::KeyEvent {
key: engine::Key::Backspace,
..
}) => {
state.input.pop();
}
Some(engine::KeyEvent {
key: engine::Key::Enter,
..
}) => {
let attempt = std::mem::take(&mut state.input);
match unix.users().authenticate(user, &attempt, unix.groups()) {
Ok(credentials) => {
unix.record_login_attempt(user, true);
let _ = crossterm::execute!(std::io::stdout(), LeaveAlternateScreen);
let _ = disable_raw_mode();
return Ok(credentials);
}
Err(_) => {
unix.record_login_attempt(user, false);
state.failure = Some("Login incorrect".to_owned());
}
}
}
_ => {}
},
Ok(_) => {}
Err(_) => break,
}
print!("\x1b[?25l");
columns = crossterm::terminal::size()
.map(|(c, _)| usize::from(c))
.unwrap_or(FALLBACK_COLUMNS);
frame = state.frame_with_width(columns);
print!("{frame}");
let (row, col) = state.cursor_position(columns);
print!("\x1b[{row};{col}H\x1b[?25h");
let _ = std::io::stdout().flush();
}
let _ = crossterm::execute!(std::io::stdout(), LeaveAlternateScreen);
let _ = disable_raw_mode();
Err("login cancelled".to_owned())
}
pub fn run_windows(
windows: &os::windows::Windows,
display_name: &str,
host: &str,
user: &str,
) -> Result<engine::ActorId, String> {
let mut state = LoginScreen::new(display_name, host, user);
state.hint = windows
.users()
.by_name(user)
.and_then(|account| account.hint().map(str::to_owned));
let _raw = enable_raw_mode();
let _ = crossterm::execute!(std::io::stdout(), EnterAlternateScreen);
let mut columns = crossterm::terminal::size()
.map(|(c, _)| usize::from(c))
.unwrap_or(FALLBACK_COLUMNS);
let mut frame = state.frame_with_width(columns);
print!("{frame}");
let (row, col) = state.cursor_position(columns);
print!("\x1b[{row};{col}H\x1b[?25h");
let _ = std::io::stdout().flush();
loop {
match event::read() {
Ok(Event::Key(key)) => match crate::host::translate_key(&key) {
Some(engine::KeyEvent {
key: engine::Key::Character,
character: Some('c' | 'd'),
ctrl: true,
..
}) => break,
Some(engine::KeyEvent {
key: engine::Key::Character,
character: Some(ch),
ctrl: false,
..
}) => {
state.input.push(ch);
state.failure = None;
}
Some(engine::KeyEvent {
key: engine::Key::Backspace,
..
}) => {
state.input.pop();
}
Some(engine::KeyEvent {
key: engine::Key::Enter,
..
}) => {
let attempt = std::mem::take(&mut state.input);
match windows.authenticate(user, &attempt) {
Ok(actor) => {
let _ = crossterm::execute!(std::io::stdout(), LeaveAlternateScreen);
let _ = disable_raw_mode();
return Ok(actor);
}
Err(_) => {
state.failure = Some("Login incorrect".to_owned());
}
}
}
_ => {}
},
Ok(_) => {}
Err(_) => break,
}
print!("\x1b[?25l");
columns = crossterm::terminal::size()
.map(|(c, _)| usize::from(c))
.unwrap_or(FALLBACK_COLUMNS);
frame = state.frame_with_width(columns);
print!("{frame}");
let (row, col) = state.cursor_position(columns);
print!("\x1b[{row};{col}H\x1b[?25h");
let _ = std::io::stdout().flush();
}
let _ = crossterm::execute!(std::io::stdout(), LeaveAlternateScreen);
let _ = disable_raw_mode();
Err("login cancelled".to_owned())
}
#[cfg(test)]
mod tests {
use super::{LoginScreen, PLACEHOLDER, visible};
fn screen_with_failure() -> LoginScreen {
let mut state = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo");
state.input.push('x');
state.failure = Some("Login incorrect".to_owned());
state.hint = Some("demo".to_owned());
state
}
#[test]
fn empty_box_shows_the_placeholder() {
let frame = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo").frame();
assert!(
frame.contains(PLACEHOLDER),
"empty box invites typing: {frame}"
);
assert!(frame.contains("UBUNTU 24.04 LTS"), "banner names the OS");
assert!(frame.contains("demo"), "prompt shows user");
assert!(
!frame.contains("login:"),
"prompt no longer shows login label"
);
assert!(!frame.contains("•"), "nothing typed yet");
}
#[test]
fn typed_characters_render_as_dots_and_dismiss_the_placeholder() {
let mut state = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo");
state.input.push_str("abc");
let frame = state.frame();
assert!(frame.contains("•••"));
assert!(!frame.contains(PLACEHOLDER));
}
fn assert_lines_fit(frame: &str, columns: usize) {
for line in frame.split("\r\n") {
let width = visible(line);
assert!(
width <= columns,
"line of {width} columns overflows a {columns}-column terminal: {line:?}"
);
}
}
#[test]
fn frames_fit_narrow_terminals() {
for columns in [20usize, 30, 40, 50, 60, 80, 120] {
let mut state = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo");
state.input.push_str("secret");
state.failure = Some("Login incorrect".to_owned());
state.hint = Some("demo".to_owned());
assert_lines_fit(&state.frame_with_width(columns), columns);
}
}
#[test]
fn banner_stays_aligned_with_its_own_rules() {
let frame = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo").frame();
let lines: Vec<&str> = frame.split("\r\n").collect();
let top = visible(lines[0]) - visible("╔");
let middle = visible(lines[1]) - visible("║");
let bottom = visible(lines[2]) - visible("╚");
assert_eq!(top, middle, "banner edges misaligned: {frame:?}");
assert_eq!(middle, bottom);
}
#[test]
fn narrow_box_drops_the_placeholder_instead_of_wrapping() {
let frame = LoginScreen::new("Ubuntu 24.04 LTS", "demo-host", "demo").frame_with_width(24);
assert!(
!frame.contains(PLACEHOLDER),
"placeholder wider than the box would wrap"
);
}
#[test]
fn failure_reveals_the_hint_below_the_box() {
let frame = screen_with_failure().frame();
assert!(frame.contains("Login incorrect"));
assert!(frame.contains("Hint: demo"));
assert!(frame.contains("•"));
}
}