use anyhow::{Context, Result};
use std::path::{Path, PathBuf};
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
pub struct ExecResult {
pub raw_output: Vec<u8>,
pub exit_code: Option<i32>,
pub timed_out: bool,
}
pub async fn execute_command(
commands: &[&str],
shell: &str,
rows: u16,
cols: u16,
timeout: Duration,
) -> Result<ExecResult> {
execute_command_in_dir(commands, shell, rows, cols, timeout, None).await
}
pub async fn execute_command_in_dir(
commands: &[&str],
shell: &str,
rows: u16,
cols: u16,
timeout: Duration,
working_dir: Option<&Path>,
) -> Result<ExecResult> {
let size = pty_process::Size::new(rows, cols);
let (pty, pts) = pty_process::open().context("Failed to open PTY")?;
pty.resize(size).context("Failed to resize PTY")?;
let cmd = pty_process::Command::new(shell)
.args(["-l", "-i"])
.env("TERM", "xterm-256color");
let cmd = match working_dir {
Some(dir) => cmd.current_dir(dir),
None => cmd,
};
let mut child = cmd.spawn(pts).context("Failed to spawn shell")?;
let (mut reader, mut writer) = pty.into_split();
let prompt_bytes = read_until_idle(
&mut reader,
Duration::from_millis(500),
Duration::from_secs(5),
)
.await?;
let nonce = format!("{:06x}", rand_u32() & 0x00ff_ffff);
let sentinel = format!("{}S_{}__", SENTINEL_HEAD, nonce);
let cut_marker = format!("#TS{}", nonce);
let mut raw_after_prompt: Vec<u8> = Vec::new();
let deadline = tokio::time::Instant::now() + timeout;
let clean_prompt = strip_title_sequences(&prompt_bytes);
let mut check_parser = vt100::Parser::new(rows, cols, 0);
check_parser.process(&clean_prompt);
let initial_prompt_col = check_parser.screen().cursor_position().1;
writer
.write_all(b"clear 2>/dev/null || printf '\\033[H\\033[2J'\n")
.await
.context("Failed to write screen reset to PTY")?;
read_until_prompt(
&mut reader,
&mut raw_after_prompt,
&mut check_parser,
initial_prompt_col,
deadline,
)
.await?;
let prompt_rows = prompt_height(check_parser.screen());
let capture_start = find_clear_sequence(&raw_after_prompt);
let prompt_col = check_parser.screen().cursor_position().1;
let prompt_prefix = prompt_prefix_rows(check_parser.screen(), cols);
for cmd in commands {
writer
.write_all(format!("{}\n", cmd).as_bytes())
.await
.context("Failed to write command to PTY")?;
read_until_prompt(
&mut reader,
&mut raw_after_prompt,
&mut check_parser,
prompt_col,
deadline,
)
.await?;
}
let bookkeeping_start = raw_after_prompt.len();
writer
.write_all(
format!(
"{BOOKKEEPING_PREFIX}$?; echo \"{SENTINEL_HEAD}\"\"S_{nonce}__:${BOOKKEEPING_VAR}\" {cut_marker}\n"
)
.as_bytes(),
)
.await
.context("Failed to write sentinel to PTY")?;
let mut buf = [0u8; 4096];
let mut found_sentinel = false;
loop {
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
break;
}
let read_timeout = remaining.min(Duration::from_millis(300));
match tokio::time::timeout(read_timeout, reader.read(&mut buf)).await {
Ok(Ok(0)) => break,
Ok(Ok(n)) => {
let chunk = &buf[..n];
raw_after_prompt.extend_from_slice(chunk);
let clean_chunk = strip_title_sequences(chunk);
check_parser.process(&clean_chunk);
if sentinel_printed(check_parser.screen(), cols, &sentinel) {
found_sentinel = true;
break;
}
}
Ok(Err(e)) => {
if e.raw_os_error() == Some(5) {
break;
}
return Err(anyhow::anyhow!("PTY read error: {}", e));
}
Err(_) => {
if sentinel_printed(check_parser.screen(), cols, &sentinel) {
found_sentinel = true;
break;
}
continue;
}
}
}
let mut captured_exit: Option<i32> = None;
let final_output = if found_sentinel {
let screen_rows: Vec<String> = check_parser.screen().rows(0, cols).collect();
let status_prefix = format!("{}:", sentinel);
captured_exit = screen_rows.iter().find_map(|line| {
if line.contains(&cut_marker) {
return None;
}
line.trim()
.strip_prefix(&status_prefix)
.and_then(|rest| rest.trim().parse::<i32>().ok())
});
let mut kept = captured_bytes(
&prompt_bytes,
&raw_after_prompt,
capture_start,
bookkeeping_start,
);
let erase = erase_trailing_prompt(&kept, rows, cols, prompt_rows, &prompt_prefix);
kept.extend_from_slice(&erase);
kept
} else {
captured_bytes(
&prompt_bytes,
&raw_after_prompt,
capture_start,
raw_after_prompt.len(),
)
};
if found_sentinel {
let _ = writer.write_all(b"exit\n").await;
}
drop(writer);
let shell_status = match tokio::time::timeout(Duration::from_secs(2), child.wait()).await {
Ok(Ok(status)) => Some(status),
_ => terminate_and_reap(&mut child).await,
};
let exit_code = captured_exit.or_else(|| shell_status.and_then(|s| s.code()));
let timed_out = !found_sentinel;
Ok(ExecResult {
raw_output: final_output,
exit_code,
timed_out,
})
}
fn prompt_prefix_rows(screen: &vt100::Screen, cols: u16) -> Vec<String> {
const MAX_PROMPT_ROWS: usize = 4;
let cursor_row = screen.cursor_position().0 as usize;
let rows: Vec<String> = screen.rows(0, cols).collect();
let mut prefix = Vec::new();
for offset in 1..=MAX_PROMPT_ROWS.min(cursor_row) {
let text = rows[cursor_row - offset].trim_end().to_string();
if text.is_empty() {
break;
}
prefix.push(text);
}
prefix
}
fn strip_trailing_prompt(rows: &[String], cut: usize, prompt_prefix: &[String]) -> usize {
let mut idx = cut;
for expected in prompt_prefix {
let mut candidate = idx;
while candidate > 0 && rows[candidate - 1].trim_end().is_empty() {
candidate -= 1;
}
if candidate == 0 || rows[candidate - 1].trim_end() != *expected {
break;
}
idx = candidate - 1;
}
idx
}
const CLEAR_SCREEN: &[u8] = b"\x1b[2J";
fn find_clear_sequence(data: &[u8]) -> Option<usize> {
data.windows(CLEAR_SCREEN.len())
.position(|window| window == CLEAR_SCREEN)
}
fn captured_bytes(
prompt_bytes: &[u8],
raw: &[u8],
capture_start: Option<usize>,
end: usize,
) -> Vec<u8> {
let end = end.min(raw.len());
match capture_start {
Some(start) if start < end => {
let mut out = Vec::with_capacity(end - start + CURSOR_HOME.len());
out.extend_from_slice(CURSOR_HOME);
out.extend_from_slice(&strip_title_sequences(&raw[start..end]));
out
}
_ => {
let mut out = strip_title_sequences(prompt_bytes);
out.extend_from_slice(&strip_title_sequences(&raw[..end]));
out
}
}
}
const CURSOR_HOME: &[u8] = b"\x1b[H";
fn erase_trailing_prompt(
data: &[u8],
rows: u16,
cols: u16,
prompt_rows: usize,
prompt_prefix: &[String],
) -> Vec<u8> {
let mut parser = vt100::Parser::new(rows, cols, 0);
parser.process(data);
let screen = parser.screen();
let cursor_row = screen.cursor_position().0;
let input_row = logical_line_start(screen, cursor_row) as usize;
let screen_rows: Vec<String> = screen.rows(0, cols).collect();
let by_height = input_row.saturating_sub(prompt_rows.saturating_sub(1));
let by_text = strip_trailing_prompt(&screen_rows, input_row, prompt_prefix);
let first_prompt_row = by_height.min(by_text);
let mut out = Vec::from(b"\r\x1b[0m".as_slice());
let up = cursor_row as usize - first_prompt_row.min(cursor_row as usize);
if up > 0 {
out.extend_from_slice(format!("\x1b[{}A", up).as_bytes());
}
out.extend_from_slice(b"\x1b[J");
out
}
fn prompt_height(screen: &vt100::Screen) -> usize {
const MAX_PROMPT_ROWS: usize = 4;
(screen.cursor_position().0 as usize + 1).clamp(1, MAX_PROMPT_ROWS)
}
fn flatten_screen(rows: &[String], cols: u16) -> String {
let mut flat = String::new();
for row in rows {
let mut width = 0usize;
for ch in row.chars() {
flat.push(ch);
width += 1;
}
for _ in width..cols as usize {
flat.push(' ');
}
}
flat
}
fn sentinel_printed(screen: &vt100::Screen, cols: u16, sentinel: &str) -> bool {
let rows: Vec<String> = screen.rows(0, cols).collect();
flatten_screen(&rows, cols).contains(sentinel)
}
fn logical_line_start(screen: &vt100::Screen, row: u16) -> u16 {
let mut start = row;
while start > 0 && screen.row_wrapped(start - 1) {
start -= 1;
}
start
}
async fn terminate_and_reap(child: &mut tokio::process::Child) -> Option<std::process::ExitStatus> {
if let Some(pid) = child.id() {
let pgid = pid as i32;
unsafe {
libc::kill(-pgid, libc::SIGTERM);
}
if let Ok(Ok(status)) = tokio::time::timeout(Duration::from_millis(500), child.wait()).await
{
return Some(status);
}
unsafe {
libc::kill(-pgid, libc::SIGKILL);
}
} else {
let _ = child.start_kill();
}
tokio::time::timeout(Duration::from_secs(2), child.wait())
.await
.ok()
.and_then(|r| r.ok())
}
pub async fn execute_command_simple(
command: &str,
shell: &str,
rows: u16,
cols: u16,
timeout: Duration,
) -> Result<ExecResult> {
execute_command_simple_in_dir(command, shell, rows, cols, timeout, None).await
}
pub async fn execute_command_simple_in_dir(
command: &str,
shell: &str,
rows: u16,
cols: u16,
timeout: Duration,
working_dir: Option<&Path>,
) -> Result<ExecResult> {
let size = pty_process::Size::new(rows, cols);
let (pty, pts) = pty_process::open().context("Failed to open PTY")?;
pty.resize(size).context("Failed to resize PTY")?;
let cmd = pty_process::Command::new(shell)
.args(["-c", command])
.env("TERM", "xterm-256color");
let cmd = match working_dir {
Some(dir) => cmd.current_dir(dir),
None => cmd,
};
let mut child = cmd.spawn(pts).context("Failed to spawn command")?;
let (mut reader, _writer) = pty.into_split();
let mut all_output: Vec<u8> = Vec::new();
let mut buf = [0u8; 4096];
let result = tokio::time::timeout(timeout, async {
loop {
match reader.read(&mut buf).await {
Ok(0) => break,
Ok(n) => all_output.extend_from_slice(&buf[..n]),
Err(e) => {
if e.raw_os_error() == Some(5) {
break;
}
return Err(anyhow::anyhow!("Read error: {}", e));
}
}
}
Ok(())
})
.await;
let timed_out = result.is_err();
let exit_code = if timed_out {
terminate_and_reap(&mut child).await.and_then(|s| s.code())
} else {
match tokio::time::timeout(Duration::from_secs(2), child.wait()).await {
Ok(Ok(status)) => status.code(),
_ => terminate_and_reap(&mut child).await.and_then(|s| s.code()),
}
};
Ok(ExecResult {
raw_output: all_output,
exit_code,
timed_out,
})
}
pub fn resolve_working_directory(path: &Path) -> Result<PathBuf> {
let raw = path.to_string_lossy();
let expanded = if raw == "~" {
PathBuf::from(
std::env::var_os("HOME")
.ok_or_else(|| anyhow::anyhow!("Cannot expand '~': HOME is not set"))?,
)
} else if let Some(rest) = raw.strip_prefix("~/") {
PathBuf::from(
std::env::var_os("HOME")
.ok_or_else(|| anyhow::anyhow!("Cannot expand '{}': HOME is not set", raw))?,
)
.join(rest)
} else if raw.starts_with('~') {
anyhow::bail!(
"Unsupported working directory '{}': only '~' and '~/' expansion are supported",
raw
);
} else {
path.to_path_buf()
};
let resolved = expanded.canonicalize().with_context(|| {
format!(
"Working directory '{}' does not exist or cannot be accessed",
path.display()
)
})?;
if !resolved.is_dir() {
anyhow::bail!("Working directory '{}' is not a directory", path.display());
}
Ok(resolved)
}
const SENTINEL_HEAD: &str = "__T";
const BOOKKEEPING_VAR: &str = "__TS_EC";
const BOOKKEEPING_PREFIX: &str = "__TS_EC=";
const QUIET_PERIOD: Duration = Duration::from_millis(400);
async fn read_until_quiet(
reader: &mut pty_process::OwnedReadPty,
raw: &mut Vec<u8>,
parser: &mut vt100::Parser,
quiet_period: Duration,
deadline: tokio::time::Instant,
) -> Result<bool> {
let mut buf = [0u8; 4096];
let mut saw_output = false;
loop {
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
return Ok(saw_output);
}
match tokio::time::timeout(quiet_period.min(remaining), reader.read(&mut buf)).await {
Ok(Ok(0)) => return Ok(saw_output),
Ok(Ok(n)) => {
saw_output = true;
let chunk = &buf[..n];
raw.extend_from_slice(chunk);
parser.process(&strip_title_sequences(chunk));
}
Ok(Err(e)) => {
if e.raw_os_error() == Some(5) {
return Ok(saw_output);
}
return Err(anyhow::anyhow!("PTY read error: {}", e));
}
Err(_) => return Ok(saw_output),
}
}
}
async fn read_until_prompt(
reader: &mut pty_process::OwnedReadPty,
raw: &mut Vec<u8>,
parser: &mut vt100::Parser,
prompt_col: u16,
deadline: tokio::time::Instant,
) -> Result<()> {
let mut saw_command_activity = false;
loop {
saw_command_activity |=
read_until_quiet(reader, raw, parser, QUIET_PERIOD, deadline).await?;
if saw_command_activity && parser.screen().cursor_position().1 == prompt_col {
return Ok(());
}
if tokio::time::Instant::now() >= deadline {
return Ok(());
}
}
}
async fn read_until_idle(
reader: &mut pty_process::OwnedReadPty,
idle_timeout: Duration,
max_wait: Duration,
) -> Result<Vec<u8>> {
let mut output = Vec::new();
let mut buf = [0u8; 4096];
let deadline = tokio::time::Instant::now() + max_wait;
let mut saw_output = false;
loop {
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
break;
}
let read_timeout = idle_timeout.min(remaining);
match tokio::time::timeout(read_timeout, reader.read(&mut buf)).await {
Ok(Ok(0)) => break,
Ok(Ok(n)) => {
saw_output = true;
output.extend_from_slice(&buf[..n]);
}
Ok(Err(e)) => {
if e.raw_os_error() == Some(5) {
break;
}
return Err(anyhow::anyhow!("PTY read error: {}", e));
}
Err(_) if saw_output => break,
Err(_) => continue,
}
}
Ok(output)
}
fn rand_u32() -> u32 {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::time::SystemTime;
let mut hasher = DefaultHasher::new();
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos()
.hash(&mut hasher);
std::process::id().hash(&mut hasher);
hasher.finish() as u32
}
fn strip_title_sequences(data: &[u8]) -> Vec<u8> {
let mut result = Vec::with_capacity(data.len());
let mut i = 0;
while i < data.len() {
if data[i] == 0x1b && i + 1 < data.len() {
match data[i + 1] {
b'k' => {
i += 2;
while i < data.len() {
if data[i] == 0x1b && i + 1 < data.len() && data[i + 1] == b'\\' {
i += 2;
break;
}
i += 1;
}
continue;
}
b']' => {
if i + 3 < data.len()
&& (data[i + 2] == b'0' || data[i + 2] == b'1' || data[i + 2] == b'2')
&& data[i + 3] == b';'
{
i += 4;
while i < data.len() {
if data[i] == 0x07 {
i += 1;
break;
}
if data[i] == 0x1b && i + 1 < data.len() && data[i + 1] == b'\\' {
i += 2;
break;
}
i += 1;
}
continue;
}
result.push(data[i]);
i += 1;
}
_ => {
result.push(data[i]);
i += 1;
}
}
} else {
result.push(data[i]);
i += 1;
}
}
result
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn strips_gnu_screen_title_sequence() {
let input = b"ls -la\r\n\x1bkls\x1b\\total 123\r\n";
let output = strip_title_sequences(input);
assert_eq!(String::from_utf8_lossy(&output), "ls -la\r\ntotal 123\r\n");
}
#[test]
fn strips_osc_title_sequences_bel_and_st_terminated() {
let input = b"a\x1b]0;hello world\x07b\x1b]2;other title\x1b\\c";
let output = strip_title_sequences(input);
assert_eq!(String::from_utf8_lossy(&output), "abc");
}
fn logical_lines_of(screen: &vt100::Screen, cols: u16) -> Vec<String> {
let rows: Vec<String> = screen
.rows(0, cols)
.map(|r| format!("{:width$}", r, width = cols as usize))
.collect();
let mut lines = Vec::new();
let mut idx = 0usize;
while idx < rows.len() {
let mut line = String::new();
loop {
line.push_str(&rows[idx]);
if idx + 1 < rows.len() && screen.row_wrapped(idx as u16) {
idx += 1;
} else {
break;
}
}
lines.push(line);
idx += 1;
}
lines
}
fn pty_session(session: &str) -> (Vec<u8>, Vec<u8>, usize) {
let prompt_bytes = b"Welcome to Ubuntu 24.04 LTS\r\nLast login: never\r\n$ ".to_vec();
let mut raw = Vec::new();
raw.extend_from_slice(b"clear 2>/dev/null || printf '\\033[H\\033[2J'\r\n");
raw.extend_from_slice(b"\x1b[H\x1b[2J\x1b[3J");
raw.extend_from_slice(session.as_bytes());
let bookkeeping_start = raw.len();
raw.extend_from_slice(
b"__TS_EC=$?; echo \"__T\"\"S_abc123__:$__TS_EC\" #TSabc123\r\n__TS_abc123__:0\r\n$ ",
);
(prompt_bytes, raw, bookkeeping_start)
}
fn capture(session: &str, rows: u16, cols: u16, prompt_prefix: &[String]) -> Vec<u8> {
let (prompt_bytes, raw, bookkeeping_start) = pty_session(session);
let mut kept = captured_bytes(
&prompt_bytes,
&raw,
find_clear_sequence(&raw),
bookkeeping_start,
);
let prompt_rows = prompt_prefix.len() + 1;
kept.extend_from_slice(&erase_trailing_prompt(
&kept,
rows,
cols,
prompt_rows,
prompt_prefix,
));
kept
}
fn screen_rows(data: &[u8], rows: u16, cols: u16) -> Vec<String> {
let mut parser = vt100::Parser::new(rows, cols, 0);
parser.process(data);
parser
.screen()
.rows(0, cols)
.map(|r| r.trim_end().to_string())
.collect()
}
const SECRET: &str = "8846f7eaee8fb117ad06bdd830b7586c";
#[test]
fn capture_preserves_soft_wrapped_values() {
let session = format!("printf 'Secret hash: {SECRET}\\n'\r\nSecret hash: {SECRET}\r\n$ ",);
let kept = capture(&session, 10, 40, &[]);
let mut parser = vt100::Parser::new(10, 40, 0);
parser.process(&kept);
let screen = parser.screen();
let plain: Vec<String> = screen.rows(0, 40).collect();
assert!(
!plain.iter().any(|r| r.contains(SECRET)),
"test setup: the secret should be split across rows:\n{:#?}",
plain
);
let logical = logical_lines_of(screen, 40);
let occurrences = logical.iter().filter(|l| l.contains(SECRET)).count();
assert_eq!(
occurrences, 2,
"both the echoed command and the output must rejoin:\n{:#?}",
logical
);
}
#[test]
fn capture_starts_at_the_clear_escape() {
let kept = capture("echo hi\r\nhi\r\n$ ", 10, 40, &[]);
let text = String::from_utf8_lossy(&kept);
assert!(!text.contains("Welcome to Ubuntu"), "startup banner kept");
assert!(!text.contains("Last login"), "startup banner kept");
assert!(!text.contains("clear 2>/dev/null"), "clear echo kept");
assert!(text.contains("echo hi"), "command echo missing:\n{}", text);
}
#[test]
fn capture_cuts_bookkeeping_and_trailing_prompt() {
let kept = capture("whoami\r\nadam\r\n$ ", 10, 40, &[]);
let text = String::from_utf8_lossy(&kept);
assert!(!text.contains("__TS_"), "bookkeeping leaked:\n{}", text);
assert!(!text.contains("#TS"), "nonce marker leaked:\n{}", text);
let rows = screen_rows(&kept, 10, 40);
assert_eq!(rows[0], "whoami");
assert_eq!(rows[1], "adam");
assert_eq!(rows[2], "", "trailing prompt was not erased: {:?}", rows);
}
#[test]
fn capture_ignores_bookkeeping_text_in_command_output() {
let session = "cat capture.sh\r\n#!/bin/bash\r\n__TS_EC=$?; echo done #TSabc123\r\n\
echo 'after the marker'\r\n$ ";
let kept = capture(session, 10, 60, &[]);
let rows = screen_rows(&kept, 10, 60);
assert_eq!(rows[0], "cat capture.sh");
assert_eq!(rows[2], "__TS_EC=$?; echo done #TSabc123");
assert_eq!(rows[3], "echo 'after the marker'");
assert_eq!(rows[4], "", "capture was truncated by its own output");
}
#[test]
fn multiline_trailing_prompt_is_erased_whole() {
let mut startup = vt100::Parser::new(10, 60, 0);
startup.process(b"adam@host ~/src\r\n$ ");
let prefix = prompt_prefix_rows(startup.screen(), 60);
assert_eq!(prefix, vec!["adam@host ~/src".to_string()]);
let session = "pwd\r\n/home/adam/src\r\nadam@host ~/src\r\n$ ";
let kept = capture(session, 10, 60, &prefix);
let rows = screen_rows(&kept, 10, 60);
assert_eq!(rows[0], "pwd");
assert_eq!(rows[1], "/home/adam/src");
assert_eq!(rows[2], "", "the whole trailing prompt should be erased");
assert_eq!(rows[3], "");
}
#[test]
fn trailing_prompt_is_erased_when_its_text_changed() {
let sampled = vec!["adam@host ~/src (main)".to_string()];
let session = "git add -A\r\nadam@host ~/src (main*)\r\n$ ";
let kept = capture(session, 10, 60, &sampled);
let rows = screen_rows(&kept, 10, 60);
assert_eq!(rows[0], "git add -A");
assert_eq!(rows[1], "", "changed trailing prompt must still be erased");
}
#[test]
fn wrapped_trailing_prompt_is_erased_whole() {
let session = "ls\r\nfile1\r\nadam@host /very/deep/directory/path$ ";
let kept = capture(session, 10, 20, &[]);
let rows = screen_rows(&kept, 10, 20);
assert_eq!(rows[0], "ls");
assert_eq!(rows[1], "file1");
assert_eq!(rows[2], "", "wrapped prompt left a fragment: {:?}", rows);
assert_eq!(rows[3], "");
}
#[test]
fn erasing_a_colored_prompt_leaves_unstyled_cells() {
let session = "echo hi\r\nhi\r\n\x1b[41m$\x1b[49m ";
let kept = capture(session, 6, 20, &[]);
let mut parser = vt100::Parser::new(6, 20, 0);
parser.process(&kept);
let screen = parser.screen();
for col in 0..20 {
let cell = screen.cell(2, col).expect("cell");
assert_eq!(cell.bgcolor(), vt100::Color::Default, "col {} tinted", col);
}
}
#[test]
fn capture_without_a_clear_keeps_everything() {
let raw = b"echo hi\r\nhi\r\n$ ".to_vec();
assert_eq!(find_clear_sequence(&raw), None);
let kept = captured_bytes(b"MOTD\r\n", &raw, None, raw.len());
let text = String::from_utf8_lossy(&kept);
assert!(text.starts_with("MOTD"), "banner dropped:\n{}", text);
assert!(text.contains("echo hi"));
}
#[test]
fn clear_sequence_is_found_by_its_escape_bytes() {
let raw = b"clear 2>/dev/null || printf '\\033[H\\033[2J'\r\n\x1b[H\x1b[2Jrest";
let at = find_clear_sequence(raw).expect("clear escape");
assert_eq!(&raw[at..at + 4], b"\x1b[2J");
assert!(String::from_utf8_lossy(&raw[at..]).ends_with("rest"));
}
#[test]
fn capture_strips_title_sequences() {
let kept = capture("ls\r\n\x1bkls\x1b\\file1\r\n$ ", 10, 40, &[]);
let rows = screen_rows(&kept, 10, 40);
assert_eq!(rows[0], "ls");
assert_eq!(rows[1], "file1");
}
#[test]
fn sentinel_detection_ignores_the_echoed_input_line() {
let mut parser = vt100::Parser::new(10, 120, 0);
parser.process(b"prompt$ __TS_EC=$?; echo \"__T\"\"S_abcd12__:$__TS_EC\" #TSabcd12\r\n");
assert!(!sentinel_printed(parser.screen(), 120, "__TS_abcd12__"));
parser.process(b"__TS_abcd12__:0\r\n");
assert!(sentinel_printed(parser.screen(), 120, "__TS_abcd12__"));
}
#[test]
fn sentinel_detection_survives_a_soft_wrap() {
let mut parser = vt100::Parser::new(10, 12, 0);
parser.process(b"__TS_abcd12__:0\r\n");
assert!(sentinel_printed(parser.screen(), 12, "__TS_abcd12__"));
}
#[test]
fn prompt_height_measures_rows_on_a_cleared_screen() {
let mut one_line = vt100::Parser::new(10, 60, 0);
one_line.process(b"adam@host:~$ ");
assert_eq!(prompt_height(one_line.screen()), 1);
let mut two_line = vt100::Parser::new(10, 60, 0);
two_line.process(b"adam@host ~/src\r\n$ ");
assert_eq!(prompt_height(two_line.screen()), 2);
}
#[test]
fn single_line_prompt_has_no_prefix_rows() {
let mut startup = vt100::Parser::new(10, 60, 0);
startup.process(b"prompt$ ");
assert!(prompt_prefix_rows(startup.screen(), 60).is_empty());
}
}