@pickle-pee/genesis-cli 0.0.0

package/dist/test/interactive-tty-workbench.test.js

@@ -0,0 +1,647 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_stream_1 = require("node:stream");
+const runtime_1 = require("@pickle-pee/runtime");
+const vitest_1 = require("vitest");
+const mode_dispatch_js_1 = require("../mode-dispatch.js");
+class FakeTtyInput extends node_stream_1.PassThrough {
+    isTTY = true;
+    setRawMode(_enabled) { }
+    resume() {
+        return super.resume();
+    }
+    pause() {
+        return super.pause();
+    }
+}
+class FakeTtyOutput extends node_stream_1.PassThrough {
+    isTTY = true;
+    columns = 80;
+    rows = 24;
+}
+class VirtualScreen {
+    width;
+    height;
+    lines;
+    row = 1;
+    column = 1;
+    constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        this.lines = Array.from({ length: height }, () => Array.from({ length: width }, () => " "));
+    }
+    consume(chunk) {
+        for (let index = 0; index < chunk.length;) {
+            const char = chunk[index];
+            if (char === "\x1b") {
+                const consumed = this.consumeEscape(chunk, index);
+                index += consumed;
+                continue;
+            }
+            if (char === "\r") {
+                this.column = 1;
+                index += 1;
+                continue;
+            }
+            if (char === "\n") {
+                this.row = Math.min(this.height, this.row + 1);
+                index += 1;
+                continue;
+            }
+            this.writeChar(char);
+            index += 1;
+        }
+    }
+    snapshot() {
+        return this.lines.map((line) => line.join("").replace(/\s+$/g, "")).join("\n");
+    }
+    consumeEscape(text, start) {
+        if (text[start + 1] !== "[") {
+            return 1;
+        }
+        let end = start + 2;
+        while (end < text.length && !/[A-Za-z]/.test(text[end] ?? "")) {
+            end += 1;
+        }
+        if (end >= text.length) {
+            return text.length - start;
+        }
+        const final = text[end] ?? "";
+        const body = text.slice(start + 2, end);
+        this.applyCsi(body, final);
+        return end - start + 1;
+    }
+    applyCsi(body, final) {
+        if (final === "m" || final === "h" || final === "l" || final === "r") {
+            return;
+        }
+        if (final === "H") {
+            if (body.length === 0) {
+                this.row = 1;
+                this.column = 1;
+                return;
+            }
+            const [row, column] = body.split(";");
+            this.row = Math.max(1, Number.parseInt(row ?? "1", 10) || 1);
+            this.column = Math.max(1, Number.parseInt(column ?? "1", 10) || 1);
+            return;
+        }
+        if (final === "J") {
+            for (let row = 0; row < this.height; row += 1) {
+                this.lines[row]?.fill(" ");
+            }
+            this.row = 1;
+            this.column = 1;
+            return;
+        }
+        if (final === "K") {
+            this.lines[this.row - 1]?.fill(" ");
+            this.column = 1;
+            return;
+        }
+        if (final === "A") {
+            const amount = Math.max(1, Number.parseInt(body || "1", 10) || 1);
+            this.row = Math.max(1, this.row - amount);
+            return;
+        }
+        if (final === "C") {
+            const amount = Math.max(1, Number.parseInt(body || "1", 10) || 1);
+            this.column = Math.min(this.width, this.column + amount);
+            return;
+        }
+    }
+    writeChar(char) {
+        if (this.row < 1 || this.row > this.height || this.column < 1 || this.column > this.width) {
+            return;
+        }
+        this.lines[this.row - 1][this.column - 1] = char;
+        this.column = Math.min(this.width, this.column + 1);
+    }
+}
+function findLineIndexContaining(snapshot, needle) {
+    return snapshot.split("\n").findIndex((line) => line.includes(needle));
+}
+function countOccurrences(snapshot, needle) {
+    return snapshot.split(needle).length - 1;
+}
+class FakeInteractiveSession {
+    id = { value: "tty-test-session" };
+    state = {
+        id: this.id,
+        model: { id: "glm-5.1", displayName: "GLM 5.1", provider: "zai" },
+        toolSet: [],
+    };
+    context = {
+        sessionId: this.id,
+        workingDirectory: "/tmp",
+        mode: "interactive",
+        model: this.state.model,
+        toolSet: new Set(["bash"]),
+        taskState: { status: "idle", currentTaskId: null, startedAt: null },
+    };
+    events = (0, runtime_1.createEventBus)();
+    plan = null;
+    sessionApprovedCommands = new Set();
+    pendingPermission = null;
+    isWaitingForPermission() {
+        return this.pendingPermission !== null;
+    }
+    async prompt(input) {
+        if (input === "hello") {
+            this.emit({
+                id: "thinking-1",
+                timestamp: Date.now(),
+                sessionId: this.id,
+                category: "text",
+                type: "thinking_delta",
+                content: "...",
+            });
+            this.emit({
+                id: "text-1",
+                timestamp: Date.now(),
+                sessionId: this.id,
+                category: "text",
+                type: "text_delta",
+                content: "Hi from Genesis",
+            });
+            return;
+        }
+        if (input === "bash echo hello") {
+            if (this.sessionApprovedCommands.has("echo hello")) {
+                this.emitBashExecution("bash-echo-2", "echo hello", "Echo: hello");
+                return;
+            }
+            this.emit({
+                id: "perm-1",
+                timestamp: Date.now(),
+                sessionId: this.id,
+                category: "permission",
+                type: "permission_requested",
+                toolName: "bash",
+                toolCallId: "bash-echo-1",
+                riskLevel: "L3",
+            });
+            await new Promise((resolve) => {
+                this.pendingPermission = {
+                    callId: "bash-echo-1",
+                    toolName: "bash",
+                    command: "echo hello",
+                    resolve,
+                };
+            });
+            this.emitBashExecution("bash-echo-1", "echo hello", "Echo: hello");
+            return;
+        }
+        if (input === "bash pwd") {
+            this.emitBashExecution("bash-pwd", "pwd", "/tmp");
+            return;
+        }
+        if (input === "bash ls") {
+            this.emitBashExecution("bash-ls", "ls", "README.md\npackages");
+            return;
+        }
+        if (input === "bash cat README.md") {
+            this.emitBashExecution("bash-cat", "cat README.md", "# Genesis CLI");
+            return;
+        }
+        if (input === "bash head -n 5 README.md") {
+            this.emitBashExecution("bash-head", "head -n 5 README.md", "# Genesis CLI");
+            return;
+        }
+        if (input === 'bash tail -f "logs/app.log"') {
+            this.emitBashExecution("bash-tail", 'tail -f "logs/app.log"', "tailing logs/app.log");
+            return;
+        }
+        if (input === "bash wc -l README.md") {
+            this.emitBashExecution("bash-wc", "wc -l README.md", "42 README.md");
+            return;
+        }
+        if (input === 'bash grep -n "Genesis CLI" README.md') {
+            this.emitBashExecution("bash-grep", 'grep -n "Genesis CLI" README.md', "1:# Genesis CLI");
+            return;
+        }
+        if (input === 'bash rg -n "createToolGovernor" packages') {
+            this.emitBashExecution("bash-rg", 'rg -n "createToolGovernor" packages', "packages/app-runtime/src/governance/tool-governor.ts:1:createToolGovernor");
+            return;
+        }
+        if (input === 'bash find . -name "*.ts" -type f') {
+            this.emitBashExecution("bash-find", 'find . -name "*.ts" -type f', "./packages/app-cli/src/mode-dispatch.ts");
+            return;
+        }
+        if (input === 'bash fd -t f "governor" packages') {
+            this.emitBashExecution("bash-fd", 'fd -t f "governor" packages', "packages/app-runtime/src/governance/tool-governor.ts");
+            return;
+        }
+        if (input === "write file") {
+            this.emit({
+                id: "perm-write-1",
+                timestamp: Date.now(),
+                sessionId: this.id,
+                category: "permission",
+                type: "permission_requested",
+                toolName: "write",
+                toolCallId: "write-file-1",
+                riskLevel: "L3",
+            });
+            await new Promise((resolve) => {
+                this.pendingPermission = { callId: "write-file-1", toolName: "write", resolve };
+            });
+            return;
+        }
+        if (input === "edit file") {
+            this.emit({
+                id: "perm-edit-1",
+                timestamp: Date.now(),
+                sessionId: this.id,
+                category: "permission",
+                type: "permission_requested",
+                toolName: "edit",
+                toolCallId: "edit-file-1",
+                riskLevel: "L3",
+            });
+            await new Promise((resolve) => {
+                this.pendingPermission = { callId: "edit-file-1", toolName: "edit", resolve };
+            });
+            return;
+        }
+    }
+    async continue(input) {
+        return this.prompt(input);
+    }
+    abort() { }
+    async close() { }
+    async resolvePermission(callId, decision) {
+        if (!this.pendingPermission || this.pendingPermission.callId !== callId) {
+            throw new Error(`Unexpected permission resolution: ${callId}`);
+        }
+        if (decision === "allow_for_session" &&
+            this.pendingPermission.toolName === "bash" &&
+            this.pendingPermission.command) {
+            this.sessionApprovedCommands.add(this.pendingPermission.command);
+        }
+        const toolName = this.pendingPermission.toolName;
+        this.emit({
+            id: `resolved-${callId}`,
+            timestamp: Date.now(),
+            sessionId: this.id,
+            category: "permission",
+            type: "permission_resolved",
+            toolName,
+            toolCallId: callId,
+            decision,
+        });
+        const pending = this.pendingPermission;
+        this.pendingPermission = null;
+        pending.resolve();
+    }
+    onStateChange() {
+        return () => { };
+    }
+    async compact() { }
+    emit(event) {
+        this.events.emit(event);
+    }
+    emitBashExecution(callId, command, result) {
+        this.emit({
+            id: `tool-start-${callId}`,
+            timestamp: Date.now(),
+            sessionId: this.id,
+            category: "tool",
+            type: "tool_started",
+            toolName: "bash",
+            toolCallId: callId,
+            parameters: { command },
+        });
+        this.emit({
+            id: `tool-end-${callId}`,
+            timestamp: Date.now(),
+            sessionId: this.id,
+            category: "tool",
+            type: "tool_completed",
+            toolName: "bash",
+            toolCallId: callId,
+            status: "success",
+            durationMs: 10,
+            result,
+        });
+        this.emit({
+            id: `tool-text-${callId}`,
+            timestamp: Date.now(),
+            sessionId: this.id,
+            category: "text",
+            type: "text_delta",
+            content: result,
+        });
+    }
+    queueMultiChunkHello() {
+        this.prompt = async (input) => {
+            if (input === "hello") {
+                this.emit({
+                    id: "thinking-1",
+                    timestamp: Date.now(),
+                    sessionId: this.id,
+                    category: "text",
+                    type: "thinking_delta",
+                    content: "...",
+                });
+                for (const [index, chunk] of ["Hi", "Hi from", "Hi from Genesis"].entries()) {
+                    this.emit({
+                        id: `text-chunk-${index}`,
+                        timestamp: Date.now(),
+                        sessionId: this.id,
+                        category: "text",
+                        type: "text_delta",
+                        content: chunk,
+                    });
+                }
+                return;
+            }
+            return FakeInteractiveSession.prototype.prompt.call(this, input);
+        };
+    }
+}
+function createFakeRuntime(session) {
+    const events = (0, runtime_1.createEventBus)();
+    return {
+        createSession: () => session,
+        recoverSession: () => session,
+        events,
+        governor: (0, runtime_1.createToolGovernor)(),
+        planEngine: (0, runtime_1.createPlanEngine)(),
+        shutdown: async () => { },
+    };
+}
+async function waitFor(check, timeoutMs = 1000) {
+    const start = Date.now();
+    while (!check()) {
+        if (Date.now() - start > timeoutMs) {
+            throw new Error("Timed out waiting for condition");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+async function withPatchedProcessTty(input, output, run) {
+    const screen = new VirtualScreen(output.columns, output.rows);
+    output.on("data", (chunk) => {
+        screen.consume(chunk.toString("utf8"));
+    });
+    const stdinDescriptor = Object.getOwnPropertyDescriptor(process, "stdin");
+    const stdoutDescriptor = Object.getOwnPropertyDescriptor(process, "stdout");
+    Object.defineProperty(process, "stdin", { value: input, configurable: true });
+    Object.defineProperty(process, "stdout", { value: output, configurable: true });
+    try {
+        return await run(screen);
+    }
+    finally {
+        if (stdinDescriptor) {
+            Object.defineProperty(process, "stdin", stdinDescriptor);
+        }
+        if (stdoutDescriptor) {
+            Object.defineProperty(process, "stdout", stdoutDescriptor);
+        }
+    }
+}
+(0, vitest_1.afterEach)(() => {
+    // defensive no-op; process descriptors are restored per-test
+});
+(0, vitest_1.describe)("interactive workbench TTY", () => {
+    (0, vitest_1.it)("renders a completed assistant reply and keeps the composer visible", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("hello\r");
+            await waitFor(() => screen.snapshot().includes("Hi from Genesis"));
+            const snapshot = screen.snapshot();
+            (0, vitest_1.expect)(snapshot).toContain("hello");
+            (0, vitest_1.expect)(snapshot).toContain("Hi from Genesis");
+            (0, vitest_1.expect)(snapshot).toContain("❯");
+            const userLine = findLineIndexContaining(snapshot, "hello");
+            const assistantLine = findLineIndexContaining(snapshot, "Hi from Genesis");
+            const footerSeparatorLine = findLineIndexContaining(snapshot, "────────────────");
+            (0, vitest_1.expect)(assistantLine - userLine).toBeGreaterThanOrEqual(2);
+            (0, vitest_1.expect)(footerSeparatorLine - assistantLine).toBeLessThanOrEqual(2);
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not leave duplicate assistant lines behind across streaming updates", async () => {
+        const session = new FakeInteractiveSession();
+        session.queueMultiChunkHello();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("hello\r");
+            await waitFor(() => screen.snapshot().includes("Hi from Genesis"));
+            const snapshot = screen.snapshot();
+            (0, vitest_1.expect)(countOccurrences(snapshot, "⏺ Hi from Genesis")).toBe(1);
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("shows permission UI and clears it after allow-for-session approval", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash echo hello\r");
+            await waitFor(() => session.isWaitingForPermission());
+            await waitFor(() => screen.snapshot().includes("choice [Enter/1/2/3]>"));
+            (0, vitest_1.expect)(screen.snapshot()).toContain("bash echo hello");
+            input.write("2\r");
+            await waitFor(() => screen.snapshot().includes("Echo: hello"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("bash echo hello\r");
+            await waitFor(() => countOccurrences(screen.snapshot(), "Echo: hello") >= 2);
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash pwd", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash pwd\r");
+            await waitFor(() => screen.snapshot().includes("/tmp"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash ls", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash ls\r");
+            await waitFor(() => screen.snapshot().includes("README.md"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash cat", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash cat README.md\r");
+            await waitFor(() => screen.snapshot().includes("# Genesis CLI"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash head", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash head -n 5 README.md\r");
+            await waitFor(() => screen.snapshot().includes("# Genesis CLI"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash tail", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write('bash tail -f "logs/app.log"\r');
+            await waitFor(() => screen.snapshot().includes("tailing logs/app.log"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash wc", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("bash wc -l README.md\r");
+            await waitFor(() => screen.snapshot().includes("42 README.md"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash grep", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write('bash grep -n "Genesis CLI" README.md\r');
+            await waitFor(() => screen.snapshot().includes("1:# Genesis CLI"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash rg", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write('bash rg -n "createToolGovernor" packages\r');
+            await waitFor(() => screen.snapshot().includes("createToolGovernor"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash find", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write('bash find . -name "*.ts" -type f\r');
+            await waitFor(() => screen.snapshot().includes("./packages/app-cli/src/mode-dispatch.ts"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("does not show a permission prompt for bash fd", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write('bash fd -t f "governor" packages\r');
+            await waitFor(() => screen.snapshot().includes("tool-governor.ts"));
+            (0, vitest_1.expect)(screen.snapshot()).not.toContain("choice [Enter/1/2/3]>");
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+    (0, vitest_1.it)("keeps the user prompt visible when write/edit permissions are requested", async () => {
+        const session = new FakeInteractiveSession();
+        const runtime = createFakeRuntime(session);
+        const input = new FakeTtyInput();
+        const output = new FakeTtyOutput();
+        await withPatchedProcessTty(input, output, async (screen) => {
+            const startPromise = (0, mode_dispatch_js_1.createModeHandler)("interactive").start(runtime);
+            await waitFor(() => screen.snapshot().includes("❯"));
+            input.write("write file\r");
+            await waitFor(() => session.isWaitingForPermission());
+            await waitFor(() => screen.snapshot().includes("choice [Enter/1/2/3]>"));
+            (0, vitest_1.expect)(screen.snapshot()).toContain("write file");
+            (0, vitest_1.expect)(screen.snapshot()).toContain("Write");
+            input.write("3\r");
+            await waitFor(() => !screen.snapshot().includes("choice [Enter/1/2/3]>"));
+            input.write("edit file\r");
+            await waitFor(() => session.isWaitingForPermission());
+            await waitFor(() => screen.snapshot().includes("choice [Enter/1/2/3]>"));
+            (0, vitest_1.expect)(screen.snapshot()).toContain("edit file");
+            (0, vitest_1.expect)(screen.snapshot()).toContain("Edit");
+            input.write("3\r");
+            await waitFor(() => !screen.snapshot().includes("choice [Enter/1/2/3]>"));
+            input.write("/exit\r");
+            await startPromise;
+        });
+    }, 10000);
+});
+//# sourceMappingURL=interactive-tty-workbench.test.js.map