Skip to main content

rigspark_cli/
accessible.rs

1use rigspark_core::reports::strip_control;
2use std::io::{self, BufRead, Read, Write};
3use tokio::sync::mpsc;
4use tokio_util::sync::CancellationToken;
5
6pub fn read_answer(input: &mut impl BufRead) -> io::Result<Option<String>> {
7    let mut bytes = Vec::new();
8    input.take(259).read_until(b'\n', &mut bytes)?;
9    if bytes.is_empty() {
10        return Ok(None);
11    }
12    if bytes.last() == Some(&b'\n') {
13        bytes.pop();
14        if bytes.last() == Some(&b'\r') {
15            bytes.pop();
16        }
17    }
18    if bytes.len() > 256 {
19        return Err(io::Error::new(
20            io::ErrorKind::InvalidInput,
21            "answer exceeds 256 bytes",
22        ));
23    }
24    String::from_utf8(bytes)
25        .map(Some)
26        .map_err(|_| io::Error::new(io::ErrorKind::InvalidData, "answer must be UTF-8"))
27}
28
29pub fn stdin_answers() -> mpsc::Receiver<io::Result<String>> {
30    let (sender, receiver) = mpsc::channel(1);
31    std::thread::spawn(move || {
32        let mut input = io::stdin().lock();
33        forward_answers(&mut input, sender);
34    });
35    receiver
36}
37
38fn forward_answers(input: &mut impl BufRead, sender: mpsc::Sender<io::Result<String>>) {
39    loop {
40        match read_answer(input) {
41            Ok(Some(line)) => {
42                if sender.blocking_send(Ok(line)).is_err() {
43                    break;
44                }
45            }
46            Ok(None) => break,
47            Err(error) => {
48                let _ = sender.blocking_send(Err(error));
49                break;
50            }
51        }
52    }
53}
54
55pub(crate) async fn answer(
56    input: &mut mpsc::Receiver<io::Result<String>>,
57    cancel: &CancellationToken,
58) -> io::Result<Option<String>> {
59    let line = tokio::select! {
60        biased;
61        _ = cancel.cancelled() => return Err(io::Error::new(io::ErrorKind::Interrupted,"interactive input cancelled")),
62        line = input.recv() => line.transpose()?,
63    };
64    if line.as_ref().is_some_and(|line| line.len() > 256) {
65        return Err(io::Error::new(
66            io::ErrorKind::InvalidInput,
67            "answer exceeds 256 bytes",
68        ));
69    }
70    Ok(line)
71}
72
73fn safe_label(label: &str) -> io::Result<String> {
74    if label.len() > 8192 {
75        return Err(io::Error::new(
76            io::ErrorKind::InvalidInput,
77            "interactive label exceeds bound",
78        ));
79    }
80    Ok(strip_control(label))
81}
82
83pub(crate) fn validate_picker_choices(choices: &[String], label_bytes: usize) -> io::Result<()> {
84    let mut unique = std::collections::BTreeSet::new();
85    if choices.is_empty()
86        || choices.len() > 1000
87        || choices.iter().any(|choice| {
88            choice.trim().is_empty()
89                || choice.len() > label_bytes
90                || choice.chars().any(char::is_control)
91                || !unique.insert(choice)
92        })
93    {
94        return Err(io::Error::new(
95            io::ErrorKind::InvalidInput,
96            "invalid model choices",
97        ));
98    }
99    Ok(())
100}
101
102pub async fn pick_model(
103    title: &str,
104    choices: &[String],
105    input: &mut mpsc::Receiver<io::Result<String>>,
106    output: &mut impl Write,
107    cancel: &CancellationToken,
108) -> io::Result<Option<usize>> {
109    validate_picker_choices(choices, 256)?;
110    writeln!(output, "{}", safe_label(title)?)?;
111    for (index, choice) in choices.iter().take(20).enumerate() {
112        writeln!(output, "{}. {}", index + 1, safe_label(choice)?)?;
113    }
114    if choices.len() > 20 {
115        writeln!(
116            output,
117            "Showing first 20 of {} models. Enter any catalog number directly.",
118            choices.len()
119        )?;
120    }
121    writeln!(output, "Enter a model number, or q to cancel.")?;
122    loop {
123        output.flush()?;
124        let Some(raw) = answer(input, cancel).await? else {
125            return Ok(None);
126        };
127        let raw = raw.trim();
128        if raw == "q" {
129            return Ok(None);
130        }
131        if let Ok(number) = raw.parse::<usize>()
132            && number > 0
133            && number <= choices.len()
134        {
135            return Ok(Some(number - 1));
136        }
137        writeln!(
138            output,
139            "No such model. Enter a listed number, or q to cancel."
140        )?;
141    }
142}
143
144pub async fn confirm(
145    screen: &str,
146    title: &str,
147    lines: &[String],
148    confirm_label: &str,
149    input: &mut mpsc::Receiver<io::Result<String>>,
150    output: &mut impl Write,
151    cancel: &CancellationToken,
152) -> io::Result<bool> {
153    if lines.len() > 100 {
154        return Err(io::Error::new(
155            io::ErrorKind::InvalidInput,
156            "review exceeds bound",
157        ));
158    }
159    let mut document = format!(
160        "rigspark / {} / Accessible\n{}\n",
161        safe_label(screen)?,
162        safe_label(title)?
163    );
164    for line in lines {
165        document.push_str(&safe_label(line)?);
166        document.push('\n');
167    }
168    document.push_str(&format!(
169        "1. Cancel (default)\n2. {}\nChoose 1 or 2, then press Enter:\n",
170        safe_label(confirm_label)?
171    ));
172    if document.len() > 32768 {
173        return Err(io::Error::new(
174            io::ErrorKind::InvalidInput,
175            "review exceeds 32 KiB",
176        ));
177    }
178    output.write_all(document.as_bytes())?;
179    output.flush()?;
180    Ok(answer(input, cancel)
181        .await?
182        .is_some_and(|line| line.trim() == "2"))
183}
184
185#[cfg(test)]
186mod reader_tests {
187    use super::*;
188    use std::{io::Cursor, time::Duration};
189
190    #[test]
191    fn forwarding_stops_after_oversize_without_delivering_a_truncated_command() {
192        let (sender, mut receiver) = mpsc::channel(1);
193        let worker = std::thread::spawn(move || {
194            let mut input = Cursor::new(format!("{}\n2\n", "x".repeat(1_000_000)));
195            forward_answers(&mut input, sender);
196            input.position()
197        });
198        assert_eq!(
199            receiver.blocking_recv().unwrap().unwrap_err().kind(),
200            io::ErrorKind::InvalidInput
201        );
202        assert!(receiver.blocking_recv().is_none());
203        assert_eq!(worker.join().unwrap(), 259);
204    }
205
206    #[test]
207    fn forwarding_preserves_lines_applies_backpressure_and_stops_on_receiver_close() {
208        let (sender, mut receiver) = mpsc::channel(1);
209        let (finished, completion) = std::sync::mpsc::channel();
210        let worker = std::thread::spawn(move || {
211            let mut input = Cursor::new("line\r\n".repeat(1000));
212            forward_answers(&mut input, sender);
213            finished.send(input.position()).unwrap();
214        });
215        for _ in 0..200 {
216            assert_eq!(receiver.blocking_recv().unwrap().unwrap(), "line");
217        }
218        assert!(matches!(
219            completion.try_recv(),
220            Err(std::sync::mpsc::TryRecvError::Empty)
221        ));
222        drop(receiver);
223        let consumed = completion.recv_timeout(Duration::from_secs(2)).unwrap();
224        assert!(
225            consumed <= 202 * 6,
226            "read beyond queued and in-flight lines: {consumed}"
227        );
228        worker.join().unwrap();
229
230        let (sender, mut receiver) = mpsc::channel(2);
231        forward_answers(&mut Cursor::new("one\r\ntwo\n"), sender);
232        assert_eq!(receiver.blocking_recv().unwrap().unwrap(), "one");
233        assert_eq!(receiver.blocking_recv().unwrap().unwrap(), "two");
234        assert!(receiver.blocking_recv().is_none());
235    }
236}