Filter Windows PTY cursor sequences

Review finding: The Windows Python backend now emits raw ConPTY cursor-control sequences in normal replies, breaking an existing Python backend test and polluting user-visible output.

Review comment: - [P1] Strip ConPTY cursor-control bytes from Python output C:\Users\kalin\Documents\GitHub\mcp-repl\src\worker_process.rs:7337-7339 When the Windows PTY path is used, this raw reader forwards VT control sequences emitted by ConPTY (e.g. \u001b[?25l\u001b[15;1H\u001b[?25h) directly into MCP replies; a simple Python reply now includes these bytes and python_backend_runs_inside_mcp_repl_worker fails on Windows. Please filter/suppress the ConPTY screen-control traffic before appending stdout, otherwise Windows Python sessions leak terminal escape codes to clients.

Response: Added a Windows PTY output filter that strips ConPTY screen-control CSI sequences before append_raw_text, including split sequences, while preserving SGR sequences. Added regression assertions in python_backend_runs_inside_mcp_repl_worker and unit coverage for split ConPTY cursor sequences.

Author: t-kalinowski

src/worker_process.rs

@@ -7323,6 +7323,86 @@ where
     }))
 }
 
+#[cfg(target_family = "windows")]
+#[derive(Default)]
+struct WindowsPtyOutputFilter {
+    state: WindowsPtyOutputFilterState,
+    pending: Vec<u8>,
+}
+
+#[cfg(target_family = "windows")]
+#[derive(Default)]
+enum WindowsPtyOutputFilterState {
+    #[default]
+    Ground,
+    Escape,
+    Csi,
+}
+
+#[cfg(target_family = "windows")]
+impl WindowsPtyOutputFilter {
+    fn filter(&mut self, bytes: &[u8]) -> Vec<u8> {
+        let mut output = Vec::with_capacity(bytes.len());
+        for &byte in bytes {
+            match self.state {
+                WindowsPtyOutputFilterState::Ground => {
+                    if byte == 0x1b {
+                        self.pending.clear();
+                        self.pending.push(byte);
+                        self.state = WindowsPtyOutputFilterState::Escape;
+                    } else {
+                        output.push(byte);
+                    }
+                }
+                WindowsPtyOutputFilterState::Escape => {
+                    self.pending.push(byte);
+                    if byte == b'[' {
+                        self.state = WindowsPtyOutputFilterState::Csi;
+                    } else {
+                        output.extend_from_slice(&self.pending);
+                        self.pending.clear();
+                        self.state = WindowsPtyOutputFilterState::Ground;
+                    }
+                }
+                WindowsPtyOutputFilterState::Csi => {
+                    self.pending.push(byte);
+                    if is_csi_final_byte(byte) {
+                        if !is_conpty_screen_control_csi(&self.pending) {
+                            output.extend_from_slice(&self.pending);
+                        }
+                        self.pending.clear();
+                        self.state = WindowsPtyOutputFilterState::Ground;
+                    } else if self.pending.len() > 128 {
+                        output.extend_from_slice(&self.pending);
+                        self.pending.clear();
+                        self.state = WindowsPtyOutputFilterState::Ground;
+                    }
+                }
+            }
+        }
+        output
+    }
+}
+
+#[cfg(target_family = "windows")]
+fn is_csi_final_byte(byte: u8) -> bool {
+    (0x40..=0x7e).contains(&byte)
+}
+
+#[cfg(target_family = "windows")]
+fn is_conpty_screen_control_csi(sequence: &[u8]) -> bool {
+    if !sequence.starts_with(b"\x1b[") {
+        return false;
+    }
+    match sequence.last().copied() {
+        Some(b'@' | b'A'..=b'K' | b'P' | b'S' | b'T' | b'X' | b'f' | b'r' | b's' | b'u') => true,
+        Some(b'h' | b'l') => sequence
+            .get(2..sequence.len().saturating_sub(1))
+            .is_some_and(|params| params.starts_with(b"?")),
+        _ => false,
+    }
+}
+
 #[cfg(target_family = "windows")]
 fn spawn_blocking_output_reader<R>(
     stream: Option<R>,
@@ -7339,10 +7419,16 @@ where
     let stop_requested = Arc::new(AtomicBool::new(false));
     let handle = thread::spawn(move || {
         let mut buffer = [0u8; 8192];
+        let mut filter = WindowsPtyOutputFilter::default();
         loop {
             match stream.read(&mut buffer) {
                 Ok(0) => break,
-                Ok(n) => live_output.append_raw_text(&buffer[..n], output_stream),
+                Ok(n) => {
+                    let filtered = filter.filter(&buffer[..n]);
+                    if !filtered.is_empty() {
+                        live_output.append_raw_text(&filtered, output_stream);
+                    }
+                }
                 Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
                 Err(_) => break,
             }
@@ -8124,6 +8210,25 @@ mod tests {
         (result, kills)
     }
 
+    #[cfg(target_family = "windows")]
+    #[test]
+    fn windows_pty_output_filter_strips_split_conpty_cursor_sequences() {
+        let mut filter = WindowsPtyOutputFilter::default();
+        let mut output = filter.filter(b"\r\nmcp-repl\n\x1b[?25");
+        output.extend(filter.filter(b"l\x1b[15;1H\x1b[?25h>>> "));
+
+        assert_eq!(String::from_utf8(output).unwrap(), "\r\nmcp-repl\n>>> ");
+    }
+
+    #[cfg(target_family = "windows")]
+    #[test]
+    fn windows_pty_output_filter_preserves_sgr_sequences() {
+        let mut filter = WindowsPtyOutputFilter::default();
+        let output = filter.filter(b"\x1b[31mred\x1b[0m\n");
+
+        assert_eq!(String::from_utf8(output).unwrap(), "\x1b[31mred\x1b[0m\n");
+    }
+
     #[test]
     fn trims_echo_prefix_across_text_chunks() {
         let mut contents = vec![

tests/python_backend.rs

@@ -779,6 +779,10 @@ else:
         )
         .await?;
     let text = result_text(&result);
+    assert!(
+        !text.contains('\x1b'),
+        "did not expect terminal control sequences in a simple Python reply, got: {text:?}"
+    );
     assert!(
         text.lines().any(|line| line.trim() == "mcp-repl"),
         "expected Python worker process image to be mcp-repl, got: {text:?}"