Fix shellv2 multi-line code paste parsing (#2092)

* fix: properly handle multiline block pasting in shellv2

When users pasted multiline string blocks (e.g. from Python code),
the BrowserRepl was evaluating each line individually with `\n` mapped to Enter.
Consequently, double newlines representing empty lines within blocks prematurely triggered
the REPL to end execution contexts, preventing entire copy-paste sequences from loading correctly.

This commit updates the `BrowserWasmAdapter` to process pasted blocks via a single method
(`paste_input`), sequentially submitting and managing completion buffers.
In the frontend hook, paste multi-character sequences containing linebreaks are now captured
and passed as a solid chunk, while simple append logic remains unmodified.

Co-authored-by: KCarretto <16250309+KCarretto@users.noreply.github.com>

* fix: correctly handle multiline python code paste blocks in shellv2

Pasting multi-line Python snippets containing empty lines caused the
frontend `BrowserRepl` loop to misinterpret the empty lines as end-of-block signals when processed line-by-line. This caused premature submission and subsequently threw errors or split logic into disconnected blocks.

This fix modifies `BrowserWasmAdapter`'s `paste_input()` handler to send the entire clipboard payload buffer straight to `BrowserRepl.input(textToInput)` in one piece, correctly preserving the block logic without prematurely submitting execution on intermediate blank lines.

Co-authored-by: KCarretto <16250309+KCarretto@users.noreply.github.com>

* file cleanup and rebuild

---------

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-authored-by: KCarretto <16250309+KCarretto@users.noreply.github.com>

Author: KCarretto

tavern/internal/www/build/asset-manifest.json

@@ -141,6 +141,47 @@ export class BrowserWasmAdapter {
         }
     }
 
+    paste_input(text: string): ExecutionResult {
+        if (!this.repl) {
+            return { status: "error", message: "REPL not initialized" };
+        }
+
+        // Just pass the entire pasted text into the repl at once.
+        // If the block is complete, it will return "complete" with the whole block.
+        // We append an extra newline to ensure it evaluates blocks that end without one.
+        let textToInput = text;
+        if (!textToInput.endsWith('\n')) {
+            textToInput += '\n';
+        }
+
+        // BrowserRepl handles parsing the entire string into its internal buffer,
+        // so we can just call it once with the full string block.
+        const resultJson = this.repl.input(textToInput);
+
+        try {
+            const result = JSON.parse(resultJson);
+
+            if (result.status === "complete") {
+                if (this.isWsOpen && this.ws) {
+                    this.ws.send(JSON.stringify({
+                        kind: WebsocketMessageKind.Input,
+                        input: result.payload
+                    }));
+                } else {
+                    return { status: "error", message: "WebSocket not connected" };
+                }
+                return { status: "complete" };
+            } else if (result.status === "incomplete") {
+                return { status: "incomplete", prompt: result.prompt };
+            } else {
+                return { status: "error", message: result.message };
+            }
+        } catch (e) {
+            console.error("Failed to parse REPL result", e);
+            return { status: "error", message: "Internal REPL error" };
+        }
+    }
+
     complete(line: string, cursor: number): { suggestions: string[], start: number } {
         if (!this.repl) return { suggestions: [], start: cursor };
         const resultJson = this.repl.complete(line, cursor);

tavern/internal/www/build/index.html

@@ -892,10 +892,59 @@ export const useShellTerminal = (
         termInstance.current.onData((data) => {
             // Check if this is a paste or multi-character sequence (not starting with ESC)
             if (data.length > 1 && data.charCodeAt(0) !== 27) {
-                // Normalize newlines to \r so they trigger the "Enter" key code (13)
-                const normalized = data.replace(/\r\n/g, "\r").replace(/\n/g, "\r");
-                for (const char of normalized) {
-                    handleData(char, true);
+                // Check for connection status and block input
+                if (isLateCheckinRef.current || connectionStatusRef.current !== "connected") return;
+
+                const hasNewlines = data.includes('\r') || data.includes('\n');
+
+                if (hasNewlines) {
+                    // Normalize to \n for our adapter
+                    const normalized = data.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+
+                    const state = shellState.current;
+                    const term = termInstance.current;
+                    if (!term) return;
+
+                    // Write the pasted text to the terminal, formatting newlines appropriately
+                    const displayFormatted = normalized.replace(/\n/g, "\r\n");
+                    term.write(displayFormatted);
+                    term.write("\r\n"); // Ensure we're on a new line after paste
+
+                    // We need to prepend any existing input buffer to the paste
+                    const fullText = state.inputBuffer + normalized;
+                    state.currentBlock += fullText + "\n";
+
+                    // Call our new paste method
+                    const res = adapter.current?.paste_input(fullText);
+
+                    if (res?.status === "complete") {
+                        if (state.currentBlock.trim()) {
+                            state.history.push(state.currentBlock.trimEnd());
+                            saveHistory(state.history);
+                        }
+                        state.currentBlock = "";
+                        state.historyIndex = -1;
+                        state.inputBuffer = "";
+                        state.cursorPos = 0;
+                        state.prompt = ">>> ";
+                        term.write(state.prompt);
+                    } else if (res?.status === "incomplete") {
+                        state.prompt = res.prompt || ".. ";
+                        term.write(state.prompt);
+                        state.inputBuffer = "";
+                        state.cursorPos = 0;
+                    } else {
+                        term.write(`Error: ${res?.message}\r\n>>> `);
+                        state.currentBlock = "";
+                        state.inputBuffer = "";
+                        state.cursorPos = 0;
+                        state.prompt = ">>> ";
+                    }
+                    lastBufferHeight.current = 0;
+                } else {
+                    for (const char of data) {
+                        handleData(char, true);
+                    }
                 }
             } else {
                 handleData(data, false);