maistro 1.0.390

package/dist/pty-test-runner.js

@@ -0,0 +1,721 @@
+/**
+ * PTY Test Runner - Real terminal testing framework
+ *
+ * Uses the `expect` command (built into macOS) to run maistro
+ * in a real pseudo-terminal and test actual terminal behavior.
+ */
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+export class PTYTestRunner {
+    process = null;
+    output = '';
+    snapshots = new Map();
+    debug = false;
+    tmpScript = '';
+    tempDir;
+    constructor(options) {
+        this.debug = options?.debug ?? false;
+        this.tempDir = options?.tempDir;
+    }
+    async start(command, args = [], options) {
+        const cols = options?.cols ?? 120;
+        const rows = options?.rows ?? 24;
+        const cwd = options?.cwd;
+        // Create a temp expect script
+        this.tmpScript = path.join(os.tmpdir(), `pty-expect-${Date.now()}.exp`);
+        // Build the full command
+        const fullCommand = [command, ...args].map(arg => {
+            // Escape special characters for Tcl
+            return `"${arg.replace(/"/g, '\\"')}"`;
+        }).join(' ');
+        // Create expect script that spawns the process and forwards stdin
+        const expectScript = `#!/usr/bin/expect -f
+log_user 1
+set timeout -1
+set stty_init "rows ${rows} cols ${cols} -icrnl -inlcr -igncr"
+spawn -noecho ${fullCommand}
+
+# Read from stdin and send to the spawned process
+fconfigure stdin -blocking 0 -buffering none -translation binary
+
+proc read_stdin {} {
+  global spawn_id
+  set data [read stdin 1]
+  if {$data ne ""} {
+    send -- $data
+  }
+  after 10 read_stdin
+}
+
+proc check_eof {} {
+  if {[eof stdin]} {
+    exit
+  }
+  after 100 check_eof
+}
+
+read_stdin
+check_eof
+expect eof
+wait
+`;
+        fs.writeFileSync(this.tmpScript, expectScript);
+        fs.chmodSync(this.tmpScript, '755');
+        // Run the expect script
+        this.process = spawn('/usr/bin/expect', ['-f', this.tmpScript], {
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                LANG: 'en_US.UTF-8',
+                COLUMNS: String(cols),
+                LINES: String(rows),
+                FORCE_COLOR: '1',
+                MAISTRO_DEBUG: '',
+                MAISTRO_SKIP_DOCTOR: '1',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd,
+        });
+        this.output = '';
+        this.process.stdout?.on('data', (data) => {
+            const str = data.toString();
+            this.output += str;
+            if (this.debug) {
+                const visible = str
+                    .replace(/\x1b/g, '\\x1b')
+                    .replace(/\r/g, '\\r')
+                    .replace(/\n/g, '\\n');
+                console.log(`[PTY STDOUT]: ${visible}`);
+            }
+        });
+        this.process.stderr?.on('data', (data) => {
+            const str = data.toString();
+            // Expect sometimes outputs to stderr, capture it too
+            this.output += str;
+            if (this.debug) {
+                console.log(`[PTY STDERR]: ${str}`);
+            }
+        });
+        // Wait for initial render
+        await this.wait(500);
+    }
+    async runSequence(sequence) {
+        const steps = this.parseSequence(sequence);
+        for (const step of steps) {
+            await this.executeStep(step);
+        }
+    }
+    parseSequence(sequence) {
+        return sequence.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'))
+            .map(line => {
+            const colonIndex = line.indexOf(':');
+            if (colonIndex === -1) {
+                throw new Error(`Invalid step format: "${line}" (missing colon)`);
+            }
+            const action = line.substring(0, colonIndex);
+            const rest = line.substring(colonIndex + 1);
+            if (action === 'assertCount') {
+                const lastColonIndex = rest.lastIndexOf(':');
+                if (lastColonIndex === -1) {
+                    throw new Error(`assertCount requires format "assertCount:text:count", got: "${line}"`);
+                }
+                const text = rest.substring(0, lastColonIndex);
+                const count = parseInt(rest.substring(lastColonIndex + 1), 10);
+                if (isNaN(count)) {
+                    throw new Error(`Invalid count in assertCount: "${line}"`);
+                }
+                return { action, value: text, count };
+            }
+            if (action === 'key') {
+                const parts = rest.split(':');
+                const keyName = parts[0];
+                const repeat = parts[1] ? parseInt(parts[1], 10) : 1;
+                return { action, value: keyName, count: repeat };
+            }
+            return { action, value: rest };
+        });
+    }
+    async executeStep(step) {
+        if (this.debug) {
+            console.log(`[STEP]: ${step.action}:${step.value}${step.count !== undefined ? ':' + step.count : ''}`);
+        }
+        switch (step.action) {
+            case 'type':
+                for (const char of step.value) {
+                    this.process?.stdin?.write(char);
+                    await this.wait(10);
+                }
+                await this.wait(50);
+                break;
+            case 'paste':
+                // Write all text at once (simulates CTRL+V paste)
+                this.process?.stdin?.write(step.value);
+                await this.wait(100);
+                break;
+            case 'key':
+                const times = step.count ?? 1;
+                for (let i = 0; i < times; i++) {
+                    this.process?.stdin?.write(this.keyToSequence(step.value));
+                    await this.wait(30);
+                }
+                await this.wait(50);
+                break;
+            case 'wait':
+                await this.wait(parseInt(step.value, 10));
+                break;
+            case 'assert':
+                this.assertContains(step.value);
+                break;
+            case 'assertCount':
+                this.assertOccurrences(step.value, step.count);
+                break;
+            case 'assertNot':
+                this.assertNotContains(step.value);
+                break;
+            case 'snapshot':
+                this.snapshots.set(step.value, this.getCleanOutput());
+                break;
+            case 'debug':
+                console.log('=== DEBUG OUTPUT ===');
+                console.log('Raw output length:', this.output.length);
+                console.log('Clean output:');
+                console.log(this.getCleanOutput());
+                console.log('===================');
+                break;
+            case 'raw':
+                // Send raw bytes directly to stdin (for testing escape sequences)
+                this.process?.stdin?.write(step.value);
+                await this.wait(50);
+                break;
+            default:
+                throw new Error(`Unknown action: ${step.action}`);
+        }
+    }
+    keyToSequence(key) {
+        const keys = {
+            Enter: '\r',
+            Escape: '\x1b',
+            Backspace: '\x7f',
+            Delete: '\x1b[3~',
+            Tab: '\t',
+            ArrowUp: '\x1b[A',
+            ArrowDown: '\x1b[B',
+            ArrowLeft: '\x1b[D',
+            ArrowRight: '\x1b[C',
+            Home: '\x1b[H',
+            End: '\x1b[F',
+            PageUp: '\x1b[5~',
+            PageDown: '\x1b[6~',
+            'Ctrl+C': '\x03',
+            'Ctrl+D': '\x04',
+            'Ctrl+Z': '\x1a',
+            'Ctrl+A': '\x01',
+            'Ctrl+E': '\x05',
+            'Ctrl+J': '\x0a', // LF - reliable cross-terminal newline
+            'Shift+Enter': '\x0a', // Same as Ctrl+J - works in terminals that send LF for Shift+Enter
+            'Shift+Up': '\x1b[1;2A', // Shift+Up for history navigation
+            'Shift+Down': '\x1b[1;2B', // Shift+Down for history navigation
+        };
+        const sequence = keys[key];
+        if (!sequence) {
+            if (key.length === 1) {
+                return key;
+            }
+            throw new Error(`Unknown key: ${key}`);
+        }
+        return sequence;
+    }
+    wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Send raw bytes to stdin
+     */
+    sendRaw(data) {
+        this.process?.stdin?.write(data);
+    }
+    getCleanOutput() {
+        // First strip ANSI escape codes
+        let clean = this.output
+            .replace(/\x1b\[\?[0-9;]*[a-zA-Z]/g, '') // \x1b[?25l/h cursor hide/show (DEC private mode)
+            .replace(/\x1b\[<[0-9;]+[Mm]?/g, '') // SGR extended mouse sequences (\x1b[<button;x;yM/m) - terminator optional for partial
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '') // Standard CSI sequences
+            .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '') // OSC sequences
+            .replace(/\x1b[78]/g, '') // DEC save/restore cursor
+            .replace(/\x1b[()][0-9A-Za-z]/g, '') // Character set selection
+            // Strip mouse sequence remnants (partial sequences without escape prefix)
+            .replace(/\[<\d+;\d+;\d*[Mm]?/g, '') // [<button;x;yM/m without \x1b (including partial)
+            .replace(/\[<\d+;\d*;?/g, '') // Even more partial like [<64;60
+            .replace(/\[</g, '') // Just [< prefix
+            // Strip bare mouse remnants: patterns like 64;60;15M, 0;21;29M0;21;29m, etc.
+            .replace(/\d+;\d+;\d+[Mm]/g, '') // bare remnants like 0;50;20M or 64;60;15M
+            .replace(/;\d+;\d+[Mm]?/g, ''); // partial like ;60;15M
+        // Process to simulate terminal behavior:
+        // - \r\n or \n = newline
+        // - \r followed by text = overwrite current line
+        // - \r at end of line = just cursor positioning, keep content
+        const lines = [];
+        let currentLine = '';
+        let cursorPos = 0;
+        for (let i = 0; i < clean.length; i++) {
+            const char = clean[i];
+            if (char === '\r') {
+                // Carriage return
+                if (clean[i + 1] === '\n') {
+                    // CRLF - newline
+                    lines.push(currentLine);
+                    currentLine = '';
+                    cursorPos = 0;
+                    i++; // Skip the \n
+                }
+                else if (i + 1 < clean.length && clean[i + 1] !== '\r') {
+                    // \r followed by printable text - reset cursor to start for overwrite
+                    cursorPos = 0;
+                }
+                // else: \r at end or followed by another \r - ignore (just cursor positioning)
+            }
+            else if (char === '\n') {
+                lines.push(currentLine);
+                currentLine = '';
+                cursorPos = 0;
+            }
+            else if (char >= ' ') {
+                // Printable character - write at cursor position
+                if (cursorPos < currentLine.length) {
+                    // Overwrite existing character
+                    currentLine = currentLine.substring(0, cursorPos) + char + currentLine.substring(cursorPos + 1);
+                }
+                else {
+                    // Append
+                    currentLine += char;
+                }
+                cursorPos++;
+            }
+            // Ignore control characters except \r and \n
+        }
+        if (currentLine) {
+            lines.push(currentLine);
+        }
+        return lines.join('\n');
+    }
+    getRawOutput() {
+        return this.output;
+    }
+    /**
+     * Render output as it would appear on a real terminal screen.
+     * This simulates a fixed-size terminal with rows/cols, line wrapping,
+     * and scrolling behavior.
+     */
+    renderScreen(cols = 80, rows = 24) {
+        // Initialize screen as array of rows
+        const screen = Array(rows).fill('').map(() => ' '.repeat(cols));
+        let cursorRow = 0;
+        let cursorCol = 0;
+        let savedCursorRow = 0;
+        let savedCursorCol = 0;
+        let scrollCount = 0; // Track how many times we've scrolled
+        // Strip sequences we don't need to process
+        let data = this.output
+            .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '') // OSC sequences
+            .replace(/\x1b\[\?[0-9;]*[hl]/g, '') // DEC private mode (cursor show/hide)
+            .replace(/\x1b\[[0-9;]*m/g, '') // SGR (colors)
+            .replace(/\x1b[()][0-9A-Za-z]/g, ''); // Character set
+        let i = 0;
+        while (i < data.length) {
+            const char = data[i];
+            // Check for escape sequences
+            if (char === '\x1b') {
+                // DEC save cursor
+                if (data[i + 1] === '7') {
+                    savedCursorRow = cursorRow;
+                    savedCursorCol = cursorCol;
+                    i += 2;
+                    continue;
+                }
+                // DEC restore cursor
+                if (data[i + 1] === '8') {
+                    cursorRow = savedCursorRow;
+                    cursorCol = savedCursorCol;
+                    i += 2;
+                    continue;
+                }
+                // CSI sequence
+                if (data[i + 1] === '[') {
+                    const match = data.slice(i).match(/^\x1b\[([0-9;]*)([a-zA-Z])/);
+                    if (match) {
+                        const params = match[1];
+                        const cmd = match[2];
+                        i += match[0].length;
+                        switch (cmd) {
+                            case 'H': // Cursor position
+                            case 'f': {
+                                const parts = params.split(';');
+                                cursorRow = Math.max(0, (parseInt(parts[0] || '1', 10) - 1));
+                                cursorCol = Math.max(0, (parseInt(parts[1] || '1', 10) - 1));
+                                if (cursorRow >= rows)
+                                    cursorRow = rows - 1;
+                                if (cursorCol >= cols)
+                                    cursorCol = cols - 1;
+                                break;
+                            }
+                            case 'A': // Cursor up
+                                cursorRow = Math.max(0, cursorRow - (parseInt(params || '1', 10)));
+                                break;
+                            case 'B': // Cursor down
+                                cursorRow = Math.min(rows - 1, cursorRow + (parseInt(params || '1', 10)));
+                                break;
+                            case 'C': // Cursor forward
+                                cursorCol = Math.min(cols - 1, cursorCol + (parseInt(params || '1', 10)));
+                                break;
+                            case 'D': // Cursor back
+                                cursorCol = Math.max(0, cursorCol - (parseInt(params || '1', 10)));
+                                break;
+                            case 'J': // Clear screen
+                                // params '' or '0' = clear from cursor to end of screen
+                                // params '1' = clear from start to cursor
+                                // params '2' = clear entire screen
+                                if (params === '' || params === '0') {
+                                    // Clear from cursor to end of current line
+                                    screen[cursorRow] = screen[cursorRow].substring(0, cursorCol) + ' '.repeat(cols - cursorCol);
+                                    // Clear all lines below cursor
+                                    for (let r = cursorRow + 1; r < rows; r++) {
+                                        screen[r] = ' '.repeat(cols);
+                                    }
+                                }
+                                else if (params === '2') {
+                                    for (let r = 0; r < rows; r++) {
+                                        screen[r] = ' '.repeat(cols);
+                                    }
+                                }
+                                break;
+                            case 'K': // Clear line
+                                if (params === '' || params === '0') {
+                                    // Clear from cursor to end of line
+                                    screen[cursorRow] = screen[cursorRow].substring(0, cursorCol) + ' '.repeat(cols - cursorCol);
+                                }
+                                else if (params === '1') {
+                                    // Clear from start of line to cursor
+                                    screen[cursorRow] = ' '.repeat(cursorCol) + screen[cursorRow].substring(cursorCol);
+                                }
+                                else if (params === '2') {
+                                    // Clear entire line
+                                    screen[cursorRow] = ' '.repeat(cols);
+                                }
+                                break;
+                        }
+                        continue;
+                    }
+                }
+                // Unknown escape, skip the escape char
+                i++;
+                continue;
+            }
+            // Carriage return
+            if (char === '\r') {
+                cursorCol = 0;
+                i++;
+                continue;
+            }
+            // Newline
+            if (char === '\n') {
+                cursorRow++;
+                if (cursorRow >= rows) {
+                    // Scroll up
+                    screen.shift();
+                    screen.push(' '.repeat(cols));
+                    cursorRow = rows - 1;
+                    scrollCount++;
+                }
+                i++;
+                continue;
+            }
+            // Printable character
+            if (char >= ' ') {
+                // Write character at cursor position
+                const row = screen[cursorRow];
+                screen[cursorRow] = row.substring(0, cursorCol) + char + row.substring(cursorCol + 1);
+                cursorCol++;
+                // Handle line wrap
+                if (cursorCol >= cols) {
+                    cursorCol = 0;
+                    cursorRow++;
+                    if (cursorRow >= rows) {
+                        // Scroll up
+                        screen.shift();
+                        screen.push(' '.repeat(cols));
+                        cursorRow = rows - 1;
+                        scrollCount++;
+                    }
+                }
+            }
+            i++;
+        }
+        return screen;
+    }
+    /**
+     * Render screen and return both screen content and scroll count
+     */
+    renderScreenWithStats(cols = 80, rows = 24) {
+        // Initialize screen as array of rows
+        const screen = Array(rows).fill('').map(() => ' '.repeat(cols));
+        let cursorRow = 0;
+        let cursorCol = 0;
+        let savedCursorRow = 0;
+        let savedCursorCol = 0;
+        let scrollCount = 0;
+        // Strip sequences we don't need to process
+        let data = this.output
+            .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '') // OSC sequences
+            .replace(/\x1b\[\?[0-9;]*[hl]/g, '') // DEC private mode (cursor show/hide)
+            .replace(/\x1b\[[0-9;]*m/g, '') // SGR (colors)
+            .replace(/\x1b[()][0-9A-Za-z]/g, ''); // Character set
+        let idx = 0;
+        while (idx < data.length) {
+            const char = data[idx];
+            if (char === '\x1b') {
+                if (data[idx + 1] === '7') {
+                    savedCursorRow = cursorRow;
+                    savedCursorCol = cursorCol;
+                    idx += 2;
+                    continue;
+                }
+                if (data[idx + 1] === '8') {
+                    cursorRow = savedCursorRow;
+                    cursorCol = savedCursorCol;
+                    idx += 2;
+                    continue;
+                }
+                if (data[idx + 1] === '[') {
+                    const match = data.slice(idx).match(/^\x1b\[([0-9;]*)([a-zA-Z])/);
+                    if (match) {
+                        const params = match[1];
+                        const cmd = match[2];
+                        idx += match[0].length;
+                        switch (cmd) {
+                            case 'H':
+                            case 'f': {
+                                const parts = params.split(';');
+                                cursorRow = Math.max(0, (parseInt(parts[0] || '1', 10) - 1));
+                                cursorCol = Math.max(0, (parseInt(parts[1] || '1', 10) - 1));
+                                if (cursorRow >= rows)
+                                    cursorRow = rows - 1;
+                                if (cursorCol >= cols)
+                                    cursorCol = cols - 1;
+                                break;
+                            }
+                            case 'A':
+                                cursorRow = Math.max(0, cursorRow - (parseInt(params || '1', 10)));
+                                break;
+                            case 'B':
+                                cursorRow = Math.min(rows - 1, cursorRow + (parseInt(params || '1', 10)));
+                                break;
+                            case 'C':
+                                cursorCol = Math.min(cols - 1, cursorCol + (parseInt(params || '1', 10)));
+                                break;
+                            case 'D':
+                                cursorCol = Math.max(0, cursorCol - (parseInt(params || '1', 10)));
+                                break;
+                            case 'J':
+                                if (params === '' || params === '0') {
+                                    screen[cursorRow] = screen[cursorRow].substring(0, cursorCol) + ' '.repeat(cols - cursorCol);
+                                    for (let r = cursorRow + 1; r < rows; r++) {
+                                        screen[r] = ' '.repeat(cols);
+                                    }
+                                }
+                                else if (params === '2') {
+                                    for (let r = 0; r < rows; r++) {
+                                        screen[r] = ' '.repeat(cols);
+                                    }
+                                }
+                                break;
+                            case 'K':
+                                if (params === '' || params === '0') {
+                                    screen[cursorRow] = screen[cursorRow].substring(0, cursorCol) + ' '.repeat(cols - cursorCol);
+                                }
+                                else if (params === '1') {
+                                    screen[cursorRow] = ' '.repeat(cursorCol) + screen[cursorRow].substring(cursorCol);
+                                }
+                                else if (params === '2') {
+                                    screen[cursorRow] = ' '.repeat(cols);
+                                }
+                                break;
+                        }
+                        continue;
+                    }
+                }
+                idx++;
+                continue;
+            }
+            if (char === '\r') {
+                cursorCol = 0;
+                idx++;
+                continue;
+            }
+            if (char === '\n') {
+                cursorRow++;
+                if (cursorRow >= rows) {
+                    screen.shift();
+                    screen.push(' '.repeat(cols));
+                    cursorRow = rows - 1;
+                    scrollCount++;
+                }
+                idx++;
+                continue;
+            }
+            if (char >= ' ') {
+                const row = screen[cursorRow];
+                screen[cursorRow] = row.substring(0, cursorCol) + char + row.substring(cursorCol + 1);
+                cursorCol++;
+                if (cursorCol >= cols) {
+                    cursorCol = 0;
+                    cursorRow++;
+                    if (cursorRow >= rows) {
+                        screen.shift();
+                        screen.push(' '.repeat(cols));
+                        cursorRow = rows - 1;
+                        scrollCount++;
+                    }
+                }
+            }
+            idx++;
+        }
+        return { screen, scrollCount };
+    }
+    /**
+     * Get screen as string (rows joined by newlines, trailing spaces trimmed)
+     */
+    getScreenOutput(cols = 80, rows = 24) {
+        const { screen } = this.renderScreenWithStats(cols, rows);
+        return screen.map(line => line.trimEnd()).join('\n');
+    }
+    /**
+     * Get scroll count from last render
+     */
+    getScrollCount(cols = 80, rows = 24) {
+        return this.renderScreenWithStats(cols, rows).scrollCount;
+    }
+    /**
+     * Count occurrences in rendered screen output
+     */
+    countOccurrencesOnScreen(text, cols = 80, rows = 24) {
+        const screenOutput = this.getScreenOutput(cols, rows);
+        let count = 0;
+        let pos = 0;
+        while ((pos = screenOutput.indexOf(text, pos)) !== -1) {
+            count++;
+            pos += text.length;
+        }
+        return count;
+    }
+    getSnapshot(name) {
+        return this.snapshots.get(name);
+    }
+    countOccurrences(text) {
+        const clean = this.getCleanOutput();
+        let count = 0;
+        let pos = 0;
+        while ((pos = clean.indexOf(text, pos)) !== -1) {
+            count++;
+            pos += text.length;
+        }
+        return count;
+    }
+    /**
+     * Count occurrences in output with ANSI stripped but carriage returns kept.
+     * This can detect "visual bugs" where the terminal SHOWS duplicate text
+     * even though proper CR processing would overwrite it.
+     */
+    countOccurrencesRaw(text) {
+        // Strip ANSI codes but keep \r and \n
+        const stripped = this.output
+            .replace(/\x1b\[\?[0-9;]*[a-zA-Z]/g, '')
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+            .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, '')
+            .replace(/\x1b[78]/g, '')
+            .replace(/\x1b[()][0-9A-Za-z]/g, '');
+        let count = 0;
+        let pos = 0;
+        while ((pos = stripped.indexOf(text, pos)) !== -1) {
+            count++;
+            pos += text.length;
+        }
+        return count;
+    }
+    assertContains(text) {
+        const clean = this.getCleanOutput();
+        if (!clean.includes(text)) {
+            throw new Error(`Expected terminal to contain "${text}"\n` +
+                `Actual output (${clean.length} chars):\n` +
+                `---\n${clean}\n---`);
+        }
+    }
+    assertNotContains(text) {
+        const clean = this.getCleanOutput();
+        if (clean.includes(text)) {
+            throw new Error(`Expected terminal NOT to contain "${text}"\n` +
+                `Actual output:\n---\n${clean}\n---`);
+        }
+    }
+    assertOccurrences(text, expected) {
+        const actual = this.countOccurrences(text);
+        if (actual !== expected) {
+            throw new Error(`Expected "${text}" to appear ${expected} time(s), but found ${actual}\n` +
+                `Output:\n---\n${this.getCleanOutput()}\n---`);
+        }
+    }
+    clearOutput() {
+        this.output = '';
+    }
+    async stop() {
+        if (this.process) {
+            // Send Ctrl+C to gracefully exit
+            this.process.stdin?.write('\x03');
+            await this.wait(100);
+            this.process.stdin?.end();
+            this.process.kill();
+            this.process = null;
+        }
+        // Clean up temp script
+        if (this.tmpScript && fs.existsSync(this.tmpScript)) {
+            try {
+                fs.unlinkSync(this.tmpScript);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        // Clean up temp directory if created
+        if (this.tempDir && fs.existsSync(this.tempDir)) {
+            try {
+                fs.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Helper to create a test runner with common setup
+ */
+export async function createMaistroTestRunner(options) {
+    let cwd;
+    if (options?.useTempDir) {
+        // Create a temp directory for clean testing
+        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'maistro-test-'));
+    }
+    const runner = new PTYTestRunner({ debug: options?.debug, tempDir: cwd });
+    // Use absolute path to dist/index.js since we may be in a different cwd
+    const distPath = path.resolve(process.cwd(), 'dist/index.js');
+    await runner.start(process.execPath, [distPath], {
+        cols: options?.cols ?? 120,
+        rows: options?.rows ?? 24,
+        cwd,
+    });
+    return runner;
+}
+//# sourceMappingURL=pty-test-runner.js.map