@alexjbarnes/cockpit 0.1.1 → 0.3.0

package/dist/src/server/ws-handler.js

@@ -5,15 +5,88 @@ const ws_1 = require("ws");
 const auth_1 = require("./auth");
 // loadLastUsage no longer needed - usage is returned by loadTranscript
 const debug_logger_1 = require("./debug-logger");
+const fs_watcher_1 = require("./fs-watcher");
 const plans_1 = require("./plans");
-const session_manager_1 = require("./session-manager");
 const session_prefs_1 = require("./session-prefs");
-function createWebSocketHandler(server, sessionManager) {
+const RESIZE_PREFIX = "\x01R";
+function setupTerminalWebSocket(terminalWss, terminalManager) {
+    const heartbeat = setInterval(() => {
+        for (const ws of terminalWss.clients) {
+            const ext = ws;
+            if (ext.isAlive === false) {
+                ws.terminate();
+                continue;
+            }
+            ext.isAlive = false;
+            ws.ping();
+        }
+    }, 30000);
+    terminalWss.on("close", () => {
+        clearInterval(heartbeat);
+    });
+    terminalWss.on("connection", (ws, req) => {
+        const ext = ws;
+        ext.isAlive = true;
+        ws.on("pong", () => {
+            ext.isAlive = true;
+        });
+        const url = new URL(req.url || "", "http://localhost");
+        const terminalId = url.searchParams.get("terminalId");
+        if (!terminalId) {
+            ws.close(1008, "Missing terminalId");
+            return;
+        }
+        const terminal = terminalManager.getTerminal(terminalId);
+        if (!terminal) {
+            console.log(`[terminal-ws] terminal not found: ${terminalId.slice(0, 8)}`);
+            ws.close(1008, "Terminal not found");
+            return;
+        }
+        const wantsReplay = url.searchParams.get("replay") !== "0";
+        console.log(`[terminal-ws] connected: ${terminalId.slice(0, 8)} replay=${wantsReplay}`);
+        terminalManager.attachClient(terminalId, (data) => {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                ws.send(data);
+            }
+        });
+        if (!wantsReplay) {
+            const delta = terminalManager.getDelta(terminalId);
+            if (delta) {
+                console.log(`[terminal-ws] sending delta: ${delta.length}b`);
+                ws.send(delta);
+            }
+        }
+        let bufferSent = !wantsReplay;
+        ws.on("message", (data) => {
+            const str = data.toString();
+            if (str.startsWith(RESIZE_PREFIX)) {
+                const parts = str.slice(RESIZE_PREFIX.length).split(";");
+                const cols = parseInt(parts[0], 10);
+                const rows = parseInt(parts[1], 10);
+                const replayBuffer = !bufferSent ? terminalManager.getBuffer(terminalId) : null;
+                if (cols > 0 && rows > 0) {
+                    terminalManager.resizeTerminal(terminalId, cols, rows);
+                }
+                if (!bufferSent) {
+                    bufferSent = true;
+                    if (replayBuffer) {
+                        ws.send("\x1b[2J\x1b[3J\x1b[H" + replayBuffer);
+                    }
+                }
+                return;
+            }
+            terminalManager.writeToTerminal(terminalId, str);
+        });
+        ws.on("close", () => {
+            console.log(`[terminal-ws] disconnected: ${terminalId.slice(0, 8)}`);
+            terminalManager.detachClient(terminalId);
+        });
+    });
+}
+function createWebSocketHandler(server, sessionManager, terminalManager) {
     const wss = new ws_1.WebSocketServer({ noServer: true });
-    // Server-side heartbeat: detect dead connections every 30s.
-    // Without this, zombie connections persist for hours (TCP keepalive default)
-    // and can cause CLI process stdout backpressure when send() buffers data
-    // into a dead socket's TCP buffer.
+    const terminalWss = new ws_1.WebSocketServer({ noServer: true });
+    setupTerminalWebSocket(terminalWss, terminalManager);
     const heartbeat = setInterval(() => {
         for (const ws of wss.clients) {
             const ext = ws;
@@ -30,15 +103,31 @@ function createWebSocketHandler(server, sessionManager) {
     });
     server.on("upgrade", (req, socket, head) => {
         const url = req.url || "";
+        console.log(`[ws] upgrade: ${url}`);
+        if (url.startsWith("/ws/terminal")) {
+            const token = (0, auth_1.extractTokenFromQuery)(url);
+            if (!token || !(0, auth_1.validateSession)(token)) {
+                socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+                socket.destroy();
+                return;
+            }
+            terminalWss.handleUpgrade(req, socket, head, (ws) => {
+                terminalWss.emit("connection", ws, req);
+            });
+            return;
+        }
         if (!url.startsWith("/ws")) {
-            return; // Let Next.js handle other upgrades (e.g. HMR)
+            console.log(`[ws] upgrade: ignoring non-ws url: ${url}`);
+            return;
         }
         const token = (0, auth_1.extractTokenFromQuery)(url);
         if (!token || !(0, auth_1.validateSession)(token)) {
+            console.log(`[ws] upgrade: auth failed for ${url} (token=${token?.slice(0, 10)}...)`);
             socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
             socket.destroy();
             return;
         }
+        console.log(`[ws] upgrade: accepted for ${url}`);
         wss.handleUpgrade(req, socket, head, (ws) => {
             wss.emit("connection", ws, req);
         });
@@ -53,10 +142,10 @@ function createWebSocketHandler(server, sessionManager) {
         });
         // Track subscriptions per session so re-connects clean up old listeners
         const sessionCleanups = new Map();
-        // Track pending permission requests with tool name and raw input
-        const pendingPermissions = new Map();
         // Lightweight status-only subscriptions for sidebar
         let watchCleanups = [];
+        // Explicit cwd watches requested by pages (e.g. changes view)
+        let cwdWatchCleanups = [];
         function subscribeSession(sessionId) {
             const prev = sessionCleanups.get(sessionId);
             if (prev) {
@@ -65,23 +154,40 @@ function createWebSocketHandler(server, sessionManager) {
             }
             const cleanups = [];
             sessionCleanups.set(sessionId, cleanups);
+            const cwd = sessionManager.getSessionCwd(sessionId);
+            if (cwd) {
+                cleanups.push((0, fs_watcher_1.watchCwd)(cwd, () => {
+                    send(ws, { type: "session:fs_changed", cwd });
+                }));
+            }
             const unsubEvent = sessionManager.subscribe(sessionId, (event) => {
                 (0, debug_logger_1.logParsedEvent)(sessionId, event);
-                handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionManager);
+                handleParsedEvent(ws, sessionId, event, sessionManager);
             });
             if (unsubEvent)
                 cleanups.push(unsubEvent);
             const unsubStatus = sessionManager.onStatus(sessionId, (status) => {
+                console.log(`[ws] onStatus fired: ${sessionId.slice(0, 8)} -> ${status}`);
                 (0, debug_logger_1.logStatus)(sessionId, status);
                 send(ws, { type: "session:status", sessionId, status });
             });
             if (unsubStatus)
                 cleanups.push(unsubStatus);
+            const unsubPending = sessionManager.onPending(sessionId, (count) => {
+                send(ws, { type: "session:pending", sessionId, count });
+            });
+            if (unsubPending)
+                cleanups.push(unsubPending);
             const unsubError = sessionManager.onError(sessionId, (error) => {
                 send(ws, { type: "session:error", sessionId, error });
             });
             if (unsubError)
                 cleanups.push(unsubError);
+            const unsubTranscript = sessionManager.onTranscript(sessionId, (messages) => {
+                send(ws, { type: "session:transcript", sessionId, messages });
+            });
+            if (unsubTranscript)
+                cleanups.push(unsubTranscript);
             const unsubSystem = sessionManager.onSystem(sessionId, (text) => {
                 send(ws, { type: "session:system", sessionId, text });
             });
@@ -156,6 +262,7 @@ function createWebSocketHandler(server, sessionManager) {
                                 messages: result.messages,
                                 status: "idle",
                                 hasMore: result.hasMore,
+                                promptHistory: result.promptHistory,
                             });
                             send(ws, { type: "session:connected", sessionId: msg.sessionId });
                             send(ws, { type: "session:info_updated", sessionId: msg.sessionId, info: result.info });
@@ -182,10 +289,6 @@ function createWebSocketHandler(server, sessionManager) {
                             if (prefs?.initData) {
                                 send(ws, { type: "session:init", sessionId: msg.sessionId, data: prefs.initData });
                             }
-                            const historyTodos = (0, session_manager_1.extractTodosFromHistory)(result.messages);
-                            if (historyTodos.length > 0) {
-                                send(ws, { type: "session:todos", sessionId: msg.sessionId, todos: historyTodos });
-                            }
                         });
                         break;
                     }
@@ -224,6 +327,36 @@ function createWebSocketHandler(server, sessionManager) {
                         if (correctedStatus !== session.info.status) {
                             sessionManager.fixStaleStatus(msg.sessionId);
                         }
+                        // Re-emit any pending permission/question requests BEFORE the
+                        // history snapshot. Otherwise, on reconnect the client lands the
+                        // assistant message with the AskUserQuestion tool_use first, and
+                        // chat-view's Place1 renders nothing until question:request
+                        // arrives 80+ms later — the chat looks stuck.
+                        const pendingReqsEarly = sessionManager.getPendingRequests(msg.sessionId);
+                        for (const req of pendingReqsEarly) {
+                            if (req.type === "question") {
+                                send(ws, {
+                                    type: "question:request",
+                                    sessionId: msg.sessionId,
+                                    requestId: req.requestId,
+                                    questions: req.toolInput,
+                                });
+                            }
+                            else {
+                                const permMsg = {
+                                    type: "permission:request",
+                                    sessionId: msg.sessionId,
+                                    requestId: req.requestId,
+                                    toolName: req.toolName,
+                                    input: req.toolInput,
+                                };
+                                if (req.planFilePath) {
+                                    permMsg.planFilePath = req.planFilePath;
+                                    permMsg.planContent = req.planContent;
+                                }
+                                send(ws, permMsg);
+                            }
+                        }
                         // If client already has messages, send only the delta to avoid
                         // re-sending 1000+ messages on every mobile reconnect.
                         // Uses the last known server message ID instead of a count, since
@@ -252,6 +385,7 @@ function createWebSocketHandler(server, sessionManager) {
                                     messages: session.messages,
                                     status: correctedStatus,
                                     hasMore: session.hasMore,
+                                    promptHistory: session.promptHistory,
                                 });
                             }
                         }
@@ -262,23 +396,23 @@ function createWebSocketHandler(server, sessionManager) {
                                 messages: session.messages,
                                 status: correctedStatus,
                                 hasMore: session.hasMore,
+                                promptHistory: session.promptHistory,
                             });
                         }
                         // Send in-progress streaming message if the CLI is mid-response.
-                        // This restores tool calls and partial text that aren't yet in the transcript.
-                        // Only send when the session is actually running; an idle session has
-                        // no in-progress streaming, and a stale snapshot would briefly show
-                        // completed agents as still running until the status:idle clears it.
-                        const snapshot = correctedStatus === "running" ? sessionManager.getStreamingSnapshot(msg.sessionId) : null;
-                        if (snapshot) {
-                            send(ws, {
-                                type: "session:streaming_snapshot",
-                                sessionId: msg.sessionId,
-                                messageId: snapshot.messageId,
-                                content: snapshot.content,
-                                toolUses: snapshot.toolUses,
-                                blocks: snapshot.blocks,
-                            });
+                        // Skip for PTY sessions - the transcript watcher provides message content.
+                        if (session.info.runtime !== "pty") {
+                            const snapshot = correctedStatus === "running" ? sessionManager.getStreamingSnapshot(msg.sessionId) : null;
+                            if (snapshot) {
+                                send(ws, {
+                                    type: "session:streaming_snapshot",
+                                    sessionId: msg.sessionId,
+                                    messageId: snapshot.messageId,
+                                    content: snapshot.content,
+                                    toolUses: snapshot.toolUses,
+                                    blocks: snapshot.blocks,
+                                });
+                            }
                         }
                         // Restore compacting indicator if compaction is in progress
                         if (sessionManager.isCompacting(msg.sessionId)) {
@@ -332,6 +466,14 @@ function createWebSocketHandler(server, sessionManager) {
                                 text: `__thinking_level::${thinkingLevel}`,
                             });
                         }
+                        const runtime = session.info.runtime;
+                        if (runtime && runtime !== "stream") {
+                            send(ws, {
+                                type: "session:system",
+                                sessionId: msg.sessionId,
+                                text: `__runtime::${runtime}`,
+                            });
+                        }
                         const currentUsage = sessionManager.getContextUsage(msg.sessionId);
                         const usage = currentUsage || session.lastUsage;
                         if (usage) {
@@ -342,12 +484,7 @@ function createWebSocketHandler(server, sessionManager) {
                             });
                         }
                         subscribeSession(msg.sessionId);
-                        // Rebuild todos from last TodoWrite in history
-                        const tTodos0 = performance.now();
-                        const fullBuffer = sessionManager.getTranscriptBuffer(msg.sessionId);
-                        sessionManager.rebuildTodosFromHistory(msg.sessionId, fullBuffer.length > 0 ? fullBuffer : session.messages);
-                        const tTodos1 = performance.now();
-                        (0, debug_logger_1.debugLog)(`[ws:${wsId}] session ${sid} rebuildTodos in ${(tTodos1 - tTodos0).toFixed(0)}ms`);
+                        sessionManager.loadTodosFromFiles(msg.sessionId);
                         const currentTodos = sessionManager.getTodos(msg.sessionId);
                         if (currentTodos.length > 0) {
                             send(ws, {
@@ -371,33 +508,6 @@ function createWebSocketHandler(server, sessionManager) {
                             messages: sessionManager.getQueuedMessages(msg.sessionId),
                             paused: sessionManager.isQueuePaused(msg.sessionId),
                         });
-                        // Re-emit any pending permission/question requests that were
-                        // sent to a previous (now dead) WebSocket connection
-                        const pendingReqs = sessionManager.getPendingRequests(msg.sessionId);
-                        for (const req of pendingReqs) {
-                            if (req.type === "question") {
-                                send(ws, {
-                                    type: "question:request",
-                                    sessionId: msg.sessionId,
-                                    requestId: req.requestId,
-                                    questions: req.toolInput,
-                                });
-                            }
-                            else {
-                                const permMsg = {
-                                    type: "permission:request",
-                                    sessionId: msg.sessionId,
-                                    requestId: req.requestId,
-                                    toolName: req.toolName,
-                                    input: req.toolInput,
-                                };
-                                if (req.planFilePath) {
-                                    permMsg.planFilePath = req.planFilePath;
-                                    permMsg.planContent = req.planContent;
-                                }
-                                send(ws, permMsg);
-                            }
-                        }
                         const tDone = performance.now();
                         (0, debug_logger_1.debugLog)(`[ws:${wsId}] session ${sid} connect complete in ${(tDone - t0).toFixed(0)}ms`);
                     });
@@ -505,8 +615,7 @@ function createWebSocketHandler(server, sessionManager) {
                     break;
                 }
                 case "permission:response": {
-                    const pending = pendingPermissions.get(msg.requestId);
-                    pendingPermissions.delete(msg.requestId);
+                    const pending = sessionManager.getPendingRequest(msg.sessionId, msg.requestId);
                     sessionManager.removePendingRequest(msg.sessionId, msg.requestId);
                     if (msg.permissionMode === "allow_all") {
                         sessionManager.setBypassAllPermissions(msg.sessionId);
@@ -522,14 +631,15 @@ function createWebSocketHandler(server, sessionManager) {
                             suggestions = pending.permissionSuggestions;
                         }
                     }
-                    sessionManager.respondToPermission(msg.sessionId, msg.requestId, msg.allowed, pending?.toolInput, suggestions);
+                    sessionManager.respondToPermission(msg.sessionId, msg.requestId, msg.allowed, pending?.rawToolInput, suggestions);
                     break;
                 }
                 case "question:response": {
-                    const pending = pendingPermissions.get(msg.requestId);
-                    pendingPermissions.delete(msg.requestId);
+                    console.log(`[question-debug] question:response for session ${msg.sessionId.slice(0, 8)}, requestId=${msg.requestId}, hadPending=${!!sessionManager.getPendingRequest(msg.sessionId, msg.requestId)}`);
+                    const pending = sessionManager.getPendingRequest(msg.sessionId, msg.requestId);
                     sessionManager.removePendingRequest(msg.sessionId, msg.requestId);
-                    const originalQuestions = pending?.toolInput?.questions;
+                    console.log(`[question-debug] after remove, remaining pending:`, sessionManager.getPendingRequests(msg.sessionId).map((r) => r.requestId));
+                    const originalQuestions = pending?.rawToolInput?.questions;
                     sessionManager.respondToPermission(msg.sessionId, msg.requestId, true, {
                         questions: originalQuestions || [],
                         answers: msg.answers,
@@ -541,7 +651,12 @@ function createWebSocketHandler(server, sessionManager) {
                     break;
                 }
                 case "session:set_model": {
-                    sessionManager.setModel(msg.sessionId, msg.model);
+                    (0, debug_logger_1.debugLog)(`[ws] session:set_model received: sessionId=${msg.sessionId.slice(0, 8)} model=${msg.model} contextSize=${msg.contextSize ?? "(unspecified)"}`);
+                    sessionManager.setModel(msg.sessionId, msg.model, msg.contextSize);
+                    break;
+                }
+                case "session:set_model_slot": {
+                    sessionManager.setModelSlot(msg.sessionId, msg.slot, msg.modelId);
                     break;
                 }
                 case "permission:set_bypass": {
@@ -553,6 +668,10 @@ function createWebSocketHandler(server, sessionManager) {
                     }
                     break;
                 }
+                case "session:set_runtime": {
+                    sessionManager.setRuntime(msg.sessionId, msg.runtime);
+                    break;
+                }
                 case "session:restart": {
                     sessionManager.restartSession(msg.sessionId);
                     break;
@@ -570,20 +689,44 @@ function createWebSocketHandler(server, sessionManager) {
                     for (const fn of watchCleanups)
                         fn();
                     watchCleanups = [];
+                    const watchedCwds = new Set();
                     for (const id of msg.sessionIds) {
                         const unsubStatus = sessionManager.onStatus(id, (status) => {
+                            console.log(`[ws] onStatus (watch) fired: ${id.slice(0, 8)} -> ${status}`);
                             send(ws, { type: "session:status", sessionId: id, status });
                         });
-                        if (unsubStatus)
+                        if (unsubStatus) {
                             watchCleanups.push(unsubStatus);
+                        }
+                        else {
+                            console.log(`[ws] session:subscribe onStatus returned null for ${id.slice(0, 8)}`);
+                        }
+                        const unsubPending = sessionManager.onPending(id, (count) => {
+                            send(ws, { type: "session:pending", sessionId: id, count });
+                        });
+                        if (unsubPending)
+                            watchCleanups.push(unsubPending);
                         const unsubInfo = sessionManager.onInfoUpdated(id, (info) => {
                             send(ws, { type: "session:info_updated", sessionId: id, info });
                         });
                         if (unsubInfo)
                             watchCleanups.push(unsubInfo);
+                        const cwd = sessionManager.getSessionCwd(id);
+                        if (cwd && !watchedCwds.has(cwd)) {
+                            watchedCwds.add(cwd);
+                            watchCleanups.push((0, fs_watcher_1.watchCwd)(cwd, () => {
+                                send(ws, { type: "session:fs_changed", cwd });
+                            }));
+                        }
                     }
                     break;
                 }
+                case "watch:cwd": {
+                    cwdWatchCleanups.push((0, fs_watcher_1.watchCwd)(msg.cwd, () => {
+                        send(ws, { type: "session:fs_changed", cwd: msg.cwd });
+                    }));
+                    break;
+                }
             }
         });
         ws.on("close", (code, _reason) => {
@@ -597,13 +740,21 @@ function createWebSocketHandler(server, sessionManager) {
             for (const fn of watchCleanups)
                 fn();
             watchCleanups = [];
+            for (const fn of cwdWatchCleanups)
+                fn();
+            cwdWatchCleanups = [];
         });
     });
     return wss;
 }
-function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionManager) {
+function handleParsedEvent(ws, sessionId, event, sessionManager) {
+    // In PTY mode the transcript watcher is the sole source of message content.
+    // Only forward non-content events (permissions, rate limits, suggestions, etc.).
+    const isPty = sessionManager.getRuntime(sessionId) === "pty";
     switch (event.type) {
         case "thinking":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:thinking",
                 sessionId,
@@ -614,6 +765,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "text_delta":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:text",
                 sessionId,
@@ -621,6 +774,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "tool_use_start":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:tool_use",
                 sessionId,
@@ -631,6 +786,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "tool_done":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:tool_use",
                 sessionId,
@@ -641,6 +798,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "tool_result":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:tool_result",
                 sessionId,
@@ -650,6 +809,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "message_done":
+            if (isPty)
+                break;
             if (event.message) {
                 send(ws, {
                     type: "assistant:message_done",
@@ -658,7 +819,23 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
                 });
             }
             break;
+        case "streaming_snapshot":
+            if (isPty)
+                break;
+            if (event.message) {
+                send(ws, {
+                    type: "session:streaming_snapshot",
+                    sessionId,
+                    messageId: event.message.id,
+                    content: event.message.content,
+                    toolUses: event.message.toolUses,
+                    blocks: event.message.blocks,
+                });
+            }
+            break;
         case "tool_children":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:tool_children",
                 sessionId,
@@ -668,6 +845,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             });
             break;
         case "tool_progress":
+            if (isPty)
+                break;
             send(ws, {
                 type: "assistant:tool_progress",
                 sessionId,
@@ -714,7 +893,7 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
                         taskId: event.taskInfo.taskId,
                         toolUseId: event.taskInfo.toolUseId,
                         status: isProgress ? "running" : event.taskInfo.status,
-                        title: isProgress ? undefined : event.taskInfo.description,
+                        title: isProgress ? undefined : event.taskInfo.title || event.taskInfo.description,
                         description: event.taskInfo.description,
                         activity: isProgress ? event.taskInfo.description : undefined,
                         summary: event.taskInfo.summary,
@@ -727,10 +906,8 @@ function handleParsedEvent(ws, sessionId, event, pendingPermissions, sessionMana
             // before this event reaches us. If we get here, it needs user input.
             const toolName = event.toolName || "";
             const requestId = event.requestId || "";
-            if (requestId && event.rawToolInput) {
-                pendingPermissions.set(requestId, { toolName, toolInput: event.rawToolInput, permissionSuggestions: event.permissionSuggestions });
-            }
             if (toolName === "AskUserQuestion") {
+                console.log(`[question-debug] live question:request for session ${sessionId.slice(0, 8)}, requestId=${requestId}`);
                 send(ws, {
                     type: "question:request",
                     sessionId,

package/next.config.ts

@@ -3,6 +3,7 @@ import type { NextConfig } from "next";
 const nextConfig: NextConfig = {
   images: { unoptimized: true },
   allowedDevOrigins: ["192.168.0.39"],
+  serverExternalPackages: ["node-pty"],
 };
 
 export default nextConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexjbarnes/cockpit",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Web UI for Claude Code",
   "license": "Apache-2.0",
   "author": "Alex Barnes (https://github.com/alexjbarnes)",
@@ -44,6 +44,8 @@
     "lint": "biome check src/ tests/ server.ts",
     "lint:fix": "biome check --fix src/ tests/ server.ts",
     "format": "biome format --write src/ tests/ server.ts",
+    "pretest:integration": "npm run build",
+    "test:integration": "playwright test --config=tests/integration/playwright.config.ts",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -55,12 +57,16 @@
     "@pierre/diffs": "^1.1.16",
     "@radix-ui/react-slot": "^1.2.4",
     "@tailwindcss/postcss": "^4",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^6.0.0",
     "class-variance-authority": "^0.7",
     "clsx": "^2",
     "codemirror": "^6.0.2",
     "lucide-react": "^1.8.0",
     "magika": "^1.0.0",
     "next": "^16.2.4",
+    "node-pty": "^1.2.0-beta.13",
     "react": "^19",
     "react-dom": "^19",
     "react-markdown": "^10.1.0",
@@ -78,15 +84,16 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.12",
+    "@playwright/test": "^1.60.0",
     "@types/node": "^25.6.0",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "@types/uuid": "^11.0.0",
     "@types/ws": "^8",
-    "@vitest/coverage-v8": "^4.1.4",
+    "@vitest/coverage-v8": "^4.1.5",
     "tsc-alias": "^1.8.10",
     "tsx": "^4.19.2",
     "typescript": "6.0.3",
-    "vitest": "^4.1.4"
+    "vitest": "^4.1.6"
   }
 }