Rewrite terminal redraw: pipe PTY output straight to xterm

apps/desktop/native-backend/src/devtools.rs

@@ -491,6 +491,46 @@ fn release_session_runtime_resources(
     }
 }
 
+/// Decode a PTY read into a UTF-8 string, carrying any incomplete trailing
+/// multi-byte sequence across to the next read via `carry`. Genuinely invalid
+/// bytes are replaced with U+FFFD; only an unfinished-but-valid prefix is held
+/// back. Mirrors Node's `StringDecoder('utf8')`.
+fn decode_utf8_with_carry(carry: &mut Vec<u8>, bytes: &[u8]) -> String {
+    carry.extend_from_slice(bytes);
+    let mut out = String::new();
+    let mut start = 0;
+    loop {
+        match std::str::from_utf8(&carry[start..]) {
+            Ok(valid) => {
+                out.push_str(valid);
+                carry.clear();
+                return out;
+            }
+            Err(error) => {
+                let valid_up_to = error.valid_up_to();
+                // SAFETY: `valid_up_to` is, by contract, a valid UTF-8 boundary.
+                out.push_str(unsafe {
+                    std::str::from_utf8_unchecked(&carry[start..start + valid_up_to])
+                });
+                match error.error_len() {
+                    // A real invalid sequence: emit one replacement char and
+                    // advance past it, then keep decoding the rest.
+                    Some(len) => {
+                        out.push('\u{FFFD}');
+                        start += valid_up_to + len;
+                    }
+                    // Input ended mid-sequence: hold the tail for the next read.
+                    None => {
+                        let remainder = carry[start + valid_up_to..].to_vec();
+                        *carry = remainder;
+                        return out;
+                    }
+                }
+            }
+        }
+    }
+}
+
 fn spawn_output_reader(
     mut reader: Box<dyn Read + Send>,
     closed: Arc<AtomicBool>,
@@ -499,6 +539,12 @@ fn spawn_output_reader(
 ) {
     thread::spawn(move || {
         let mut buffer = [0_u8; OUTPUT_CHUNK_SIZE];
+        // Holds the bytes of a multi-byte UTF-8 sequence that was split across a
+        // read boundary. Without this, `from_utf8_lossy` would replace the split
+        // codepoint with U+FFFD, corrupting box-drawing / emoji / powerline
+        // glyphs that TUIs like Claude Code emit heavily. This mirrors Node's
+        // StringDecoder: decode the valid prefix, carry the incomplete tail.
+        let mut carry: Vec<u8> = Vec::new();
         loop {
             if closed.load(Ordering::Relaxed) {
                 break;
@@ -509,8 +555,10 @@ fn spawn_output_reader(
                     if closed.load(Ordering::Relaxed) {
                         break;
                     }
-                    let chunk = String::from_utf8_lossy(&buffer[..read]).into_owned();
-                    emit_terminal_output(&event_tx, &session_id, chunk);
+                    let chunk = decode_utf8_with_carry(&mut carry, &buffer[..read]);
+                    if !chunk.is_empty() {
+                        emit_terminal_output(&event_tx, &session_id, chunk);
+                    }
                 }
                 Err(error) => {
                     if !closed.load(Ordering::Relaxed) {
@@ -817,6 +865,60 @@ mod tests {
     use super::*;
     use std::fs;
 
+    #[test]
+    fn decodes_utf8_sequence_split_across_reads() {
+        // "é" (U+00E9) is 0xC3 0xA9. Split it across two reads.
+        let mut carry = Vec::new();
+        let first = decode_utf8_with_carry(&mut carry, &[b'a', 0xC3]);
+        assert_eq!(first, "a");
+        assert_eq!(carry, vec![0xC3]);
+        let second = decode_utf8_with_carry(&mut carry, &[0xA9, b'b']);
+        assert_eq!(second, "\u{00E9}b");
+        assert!(carry.is_empty());
+    }
+
+    #[test]
+    fn decodes_three_byte_sequence_split_at_every_boundary() {
+        // "→" (U+2192) is 0xE2 0x86 0x92. Feed one byte per read.
+        let mut carry = Vec::new();
+        assert_eq!(decode_utf8_with_carry(&mut carry, &[0xE2]), "");
+        assert_eq!(decode_utf8_with_carry(&mut carry, &[0x86]), "");
+        assert_eq!(decode_utf8_with_carry(&mut carry, &[0x92]), "\u{2192}");
+        assert!(carry.is_empty());
+    }
+
+    #[test]
+    fn decodes_four_byte_emoji_split_across_reads() {
+        // "😀" (U+1F600) is 0xF0 0x9F 0x98 0x80. Split it across three reads.
+        let mut carry = Vec::new();
+        assert_eq!(decode_utf8_with_carry(&mut carry, &[0xF0, 0x9F]), "");
+        assert_eq!(decode_utf8_with_carry(&mut carry, &[0x98]), "");
+        assert_eq!(
+            decode_utf8_with_carry(&mut carry, &[0x80, b'!']),
+            "\u{1F600}!"
+        );
+        assert!(carry.is_empty());
+    }
+
+    #[test]
+    fn leaves_no_carry_for_complete_input() {
+        let mut carry = Vec::new();
+        assert_eq!(
+            decode_utf8_with_carry(&mut carry, "plain ascii ✓".as_bytes()),
+            "plain ascii ✓"
+        );
+        assert!(carry.is_empty());
+    }
+
+    #[test]
+    fn replaces_genuinely_invalid_bytes_without_stalling() {
+        // 0xFF is never valid UTF-8; it must become U+FFFD and not be carried.
+        let mut carry = Vec::new();
+        let out = decode_utf8_with_carry(&mut carry, &[b'a', 0xFF, b'b']);
+        assert_eq!(out, "a\u{FFFD}b");
+        assert!(carry.is_empty());
+    }
+
     #[test]
     fn resolves_requested_cwd_when_directory_exists() {
         let dir = tempfile::tempdir().expect("temp dir");

apps/desktop/package.json

@@ -61,6 +61,7 @@
         "@replit/codemirror-vim": "^6.3.0",
         "@xterm/addon-fit": "^0.11.0",
         "@xterm/addon-search": "^0.16.0",
+        "@xterm/addon-serialize": "^0.14.0",
         "@xterm/addon-web-links": "^0.12.0",
         "@xterm/addon-webgl": "^0.19.0",
         "@xterm/xterm": "^6.0.0",

apps/desktop/src/features/ai/components/AIAuthTerminalModal.tsx

@@ -14,6 +14,7 @@ import { appendTerminalRawOutput } from "../../terminal/terminalRawOutput";
 import { TerminalViewport } from "../../terminal/TerminalViewport";
 import {
     EMPTY_TERMINAL_SNAPSHOT,
+    type TerminalOutputCommand,
     type TerminalSessionView,
 } from "../../terminal/terminalTypes";
 import { APP_BRAND_NAME } from "../../../app/utils/branding";
@@ -98,6 +99,37 @@ export function AIAuthTerminalModal({
     const [rawOutput, setRawOutput] = useState("");
     const [busy, setBusy] = useState(false);
     const onRefreshSetupRef = useRef(onRefreshSetup);
+    // Local output channel feeding the viewport (it pipes commands straight to
+    // xterm). rawOutput state is kept separately, only for auth-success scanning.
+    const outputListenersRef = useRef(
+        new Set<(command: TerminalOutputCommand) => void>(),
+    );
+    const outputBacklogRef = useRef<TerminalOutputCommand[]>([]);
+    const replaySnapshotRef = useRef<string | null>(null);
+
+    const emitOutputCommand = useCallback((command: TerminalOutputCommand) => {
+        const listeners = outputListenersRef.current;
+        if (listeners.size === 0) {
+            outputBacklogRef.current.push(command);
+            return;
+        }
+        for (const listener of listeners) {
+            listener(command);
+        }
+    }, []);
+
+    // Reset the viewport screen and feed it an initial buffer (e.g. on (re)start).
+    const resetOutputWithBuffer = useCallback(
+        (buffer: string) => {
+            replaySnapshotRef.current = null;
+            outputBacklogRef.current = [];
+            emitOutputCommand({ type: "clear" });
+            if (buffer) {
+                emitOutputCommand({ type: "write", data: buffer });
+            }
+        },
+        [emitOutputCommand],
+    );
 
     useEffect(() => {
         onRefreshSetupRef.current = onRefreshSetup;
@@ -137,6 +169,7 @@ export function AIAuthTerminalModal({
                         if (payload.sessionId !== sessionIdRef.current) return;
                         setSnapshot(payload);
                         setRawOutput(payload.buffer);
+                        resetOutputWithBuffer(payload.buffer);
                         setBusy(false);
                     }),
                 ),
@@ -146,6 +179,10 @@ export function AIAuthTerminalModal({
                         setRawOutput((current) =>
                             appendTerminalRawOutput(current, payload.chunk),
                         );
+                        emitOutputCommand({
+                            type: "write",
+                            data: payload.chunk,
+                        });
                     }),
                 ),
                 registerListener(
@@ -173,6 +210,7 @@ export function AIAuthTerminalModal({
         const startSession = async () => {
             setBusy(true);
             setRawOutput("");
+            resetOutputWithBuffer("");
             setSnapshot((current) => ({
                 ...current,
                 sessionId: "",
@@ -197,6 +235,7 @@ export function AIAuthTerminalModal({
                 sessionIdRef.current = nextSnapshot.sessionId;
                 setSnapshot(nextSnapshot);
                 setRawOutput(nextSnapshot.buffer);
+                resetOutputWithBuffer(nextSnapshot.buffer);
                 setBusy(false);
             } catch (error) {
                 if (disposed) return;
@@ -216,6 +255,7 @@ export function AIAuthTerminalModal({
             }
             void startSession();
         });
+        // emitOutputCommand and resetOutputWithBuffer are stable (useCallback).
 
         return () => {
             disposed = true;
@@ -230,7 +270,15 @@ export function AIAuthTerminalModal({
                 void unlisten();
             });
         };
-    }, [open, runtimeId, methodId, vaultPath, customBinaryPath]);
+    }, [
+        open,
+        runtimeId,
+        methodId,
+        vaultPath,
+        customBinaryPath,
+        emitOutputCommand,
+        resetOutputWithBuffer,
+    ]);
 
     const handleClose = useCallback(() => {
         const sessionId = sessionIdRef.current;
@@ -250,6 +298,7 @@ export function AIAuthTerminalModal({
         }
 
         setRawOutput("");
+        resetOutputWithBuffer("");
         setSnapshot(buildInitialSnapshot(runtimeId, runtimeName, vaultPath));
         setBusy(true);
 
@@ -263,6 +312,7 @@ export function AIAuthTerminalModal({
             sessionIdRef.current = nextSnapshot.sessionId;
             setSnapshot(nextSnapshot);
             setRawOutput(nextSnapshot.buffer);
+            resetOutputWithBuffer(nextSnapshot.buffer);
             setBusy(false);
         } catch (error) {
             setSnapshot((current) => ({
@@ -279,12 +329,13 @@ export function AIAuthTerminalModal({
         runtimeId,
         runtimeName,
         vaultPath,
+        resetOutputWithBuffer,
     ]);
 
     const sessionView = useMemo<TerminalSessionView>(
         () => ({
             snapshot,
-            rawOutput,
+            hasOutput: rawOutput.length > 0,
             busy,
             writeInput: async (input) => {
                 const sessionId = sessionIdRef.current;
@@ -304,9 +355,28 @@ export function AIAuthTerminalModal({
             restart: handleRetry,
             clearViewport: () => {
                 setRawOutput("");
+                resetOutputWithBuffer("");
+            },
+            subscribeOutput: (listener) => {
+                const listeners = outputListenersRef.current;
+                if (listeners.size === 0 && outputBacklogRef.current.length > 0) {
+                    const pending = outputBacklogRef.current;
+                    outputBacklogRef.current = [];
+                    for (const command of pending) {
+                        listener(command);
+                    }
+                }
+                listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            },
+            getReplaySnapshot: () => replaySnapshotRef.current,
+            saveReplaySnapshot: (serialized) => {
+                replaySnapshotRef.current = serialized;
             },
         }),
-        [snapshot, rawOutput, busy, handleRetry],
+        [snapshot, rawOutput, busy, handleRetry, resetOutputWithBuffer],
     );
 
     if (!open) return null;

apps/desktop/src/features/editor/EditorPaneContent.test.tsx

@@ -42,12 +42,20 @@ function seedTerminalRuntime(terminalId: string, rawOutput = "ready\n") {
                 snapshot: makeSnapshot({
                     sessionId: `session-${terminalId}`,
                 }),
-                rawOutput,
+                hasOutput: false,
                 busy: false,
                 launchError: null,
             },
         },
     });
+    // Output is piped through the channel; emitted now, it buffers until the
+    // viewport mounts and subscribes, then lands in xterm.
+    if (rawOutput) {
+        useTerminalRuntimeStore.getState().handleTerminalOutput({
+            sessionId: `session-${terminalId}`,
+            chunk: rawOutput,
+        });
+    }
 }
 
 function getEditorView() {