Skip to main content

host/
text.rs

1//! Output text handling shared by the blocking bash and shell jobs, ported from utils/ansi.ts (stripAnsi),
2//! utils/shell.ts (sanitizeBinaryOutput), core/tools/truncate.ts (truncateTail) and the streaming TextDecoder.
3
4const ESC: char = '\u{1b}';
5const CSI: char = '\u{9b}';
6
7/// Streaming UTF-8 decoder with WHATWG replacement (one U+FFFD per maximal invalid subpart).
8#[derive(Default)]
9pub struct Decoder {
10    pending: Vec<u8>,
11}
12
13impl Decoder {
14    pub fn decode(&mut self, data: &[u8], stream: bool) -> String {
15        self.pending.extend_from_slice(data);
16        let bytes = std::mem::take(&mut self.pending);
17        let mut out = String::new();
18        let mut rest = &bytes[..];
19        loop {
20            match std::str::from_utf8(rest) {
21                Ok(text) => {
22                    out.push_str(text);
23                    break;
24                }
25                Err(error) => {
26                    let (valid, after) = rest.split_at(error.valid_up_to());
27                    out.push_str(std::str::from_utf8(valid).unwrap_or_default());
28                    match error.error_len() {
29                        Some(len) => {
30                            out.push('\u{fffd}');
31                            rest = &after[len..];
32                        }
33                        None if stream => {
34                            self.pending = after.to_vec();
35                            break;
36                        }
37                        None => {
38                            out.push('\u{fffd}');
39                            break;
40                        }
41                    }
42                }
43            }
44        }
45        out
46    }
47}
48
49/// Chunk text as both TS paths write it: `sanitizeBinaryOutput(stripAnsi(text)).replace(/\r/g, "")`.
50pub fn clean(text: &str) -> String {
51    strip_ansi(text)
52        .chars()
53        .filter(|&c| {
54            let code = c as u32;
55            !(code <= 0x1f && !matches!(code, 0x09 | 0x0a) || (0xfff9..=0xfffb).contains(&code))
56        })
57        .collect()
58}
59
60pub fn strip_ansi(text: &str) -> String {
61    if !text.contains(ESC) && !text.contains(CSI) {
62        return text.to_owned();
63    }
64    let chars: Vec<char> = text.chars().collect();
65    let mut out = String::with_capacity(text.len());
66    let mut i = 0;
67    while i < chars.len() {
68        match osc_end(&chars, i).or_else(|| csi_end(&chars, i)) {
69            Some(end) => i = end,
70            None => {
71                out.push(chars[i]);
72                i += 1;
73            }
74        }
75    }
76    out
77}
78
79/// `\u001B\][\s\S]*?(?:\u0007|\u001B\|\u009C)`
80fn osc_end(chars: &[char], i: usize) -> Option<usize> {
81    if chars.get(i) != Some(&ESC) || chars.get(i + 1) != Some(&']') {
82        return None;
83    }
84    let mut j = i + 2;
85    while j < chars.len() {
86        match chars[j] {
87            '\u{7}' | '\u{9c}' => return Some(j + 1),
88            ESC if chars.get(j + 1) == Some(&'\\') => return Some(j + 2),
89            _ => j += 1,
90        }
91    }
92    None
93}
94
95/// `[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]`, with the regex's backtracking.
96fn csi_end(chars: &[char], i: usize) -> Option<usize> {
97    if !matches!(chars.get(i), Some(&ESC) | Some(&CSI)) {
98        return None;
99    }
100    let start = i + 1;
101    let mut most = 0;
102    while chars.get(start + most).is_some_and(|c| "[]()#;?".contains(*c)) {
103        most += 1;
104    }
105    for intermediates in (0..=most).rev() {
106        let p = start + intermediates;
107        let mut ends = Vec::new();
108        param_ends(chars, p, &mut ends);
109        ends.push(p);
110        for end in ends {
111            if chars.get(end).is_some_and(|&c| is_final(c)) {
112                return Some(end + 1);
113            }
114        }
115    }
116    None
117}
118
119fn digits(chars: &[char], at: usize, max: usize) -> usize {
120    let mut n = 0;
121    while n < max && chars.get(at + n).is_some_and(char::is_ascii_digit) {
122        n += 1;
123    }
124    n
125}
126
127/// End positions of `\d{1,4}(?:[;:]\d{0,4})*` at `p`, most preferred (greedy) first.
128fn param_ends(chars: &[char], p: usize, ends: &mut Vec<usize>) {
129    for n in (1..=digits(chars, p, 4)).rev() {
130        separators(chars, p + n, ends);
131    }
132}
133
134fn separators(chars: &[char], at: usize, ends: &mut Vec<usize>) {
135    if chars.get(at).is_some_and(|&c| c == ';' || c == ':') {
136        for n in (0..=digits(chars, at + 1, 4)).rev() {
137            separators(chars, at + 1 + n, ends);
138        }
139    }
140    ends.push(at);
141}
142
143fn is_final(c: char) -> bool {
144    c.is_ascii_digit()
145        || ('A'..='P').contains(&c)
146        || ('R'..='T').contains(&c)
147        || c == 'Z'
148        || c == 'c'
149        || ('f'..='n').contains(&c)
150        || ('q'..='u').contains(&c)
151        || matches!(c, 'y' | '=' | '>' | '<' | '~')
152}
153
154pub const DEFAULT_MAX_BYTES: usize = 50 * 1024;
155pub const DEFAULT_MAX_LINES: usize = 2000;
156
157/// truncateTail with the default limits: the last lines that fit, else the end of the last line. `None` when the text fits.
158pub fn truncate_tail(content: &str) -> Option<String> {
159    let mut lines: Vec<&str> = if content.is_empty() {
160        Vec::new()
161    } else {
162        content.split('\n').collect()
163    };
164    if content.ends_with('\n') {
165        lines.pop();
166    }
167    if lines.len() <= DEFAULT_MAX_LINES && content.len() <= DEFAULT_MAX_BYTES {
168        return None;
169    }
170    let mut kept: Vec<String> = Vec::new();
171    let mut bytes = 0;
172    for line in lines.iter().rev() {
173        if kept.len() >= DEFAULT_MAX_LINES {
174            break;
175        }
176        let size = line.len() + usize::from(!kept.is_empty());
177        if bytes + size > DEFAULT_MAX_BYTES {
178            if kept.is_empty() {
179                kept.push(tail_bytes(line, DEFAULT_MAX_BYTES).to_owned());
180            }
181            break;
182        }
183        kept.push((*line).to_owned());
184        bytes += size;
185    }
186    kept.reverse();
187    Some(kept.join("\n"))
188}
189
190/// The last `max` bytes of `text`, starting at a character boundary.
191pub fn tail_bytes(text: &str, max: usize) -> &str {
192    if text.len() <= max {
193        return text;
194    }
195    let mut start = text.len() - max;
196    while !text.is_char_boundary(start) {
197        start += 1;
198    }
199    &text[start..]
200}