rigspark_cli/
accessible.rs1use 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}