factory-factory 0.1.5 → 0.2.0

package/dist/src/backend/routers/websocket/index.js

@@ -1,4 +1,4 @@
-export { handleChatUpgrade } from './chat.handler.js';
-export { devLogsConnections, handleDevLogsUpgrade } from './dev-logs.handler.js';
-export { handleTerminalUpgrade, terminalConnections } from './terminal.handler.js';
+export { createChatUpgradeHandler, handleChatUpgrade } from './chat.handler.js';
+export { createDevLogsUpgradeHandler, devLogsConnections, handleDevLogsUpgrade, } from './dev-logs.handler.js';
+export { createTerminalUpgradeHandler, handleTerminalUpgrade, terminalConnections, } from './terminal.handler.js';
 //# sourceMappingURL=index.js.map

package/dist/src/backend/routers/websocket/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,4BAA4B,EAC5B,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC"}

package/dist/src/backend/routers/websocket/message-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function toMessageString(data: unknown): string;
+//# sourceMappingURL=message-utils.d.ts.map

package/dist/src/backend/routers/websocket/message-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-utils.d.ts","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/message-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAcrD"}

package/dist/src/backend/routers/websocket/message-utils.js

@@ -0,0 +1,16 @@
+export function toMessageString(data) {
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (Buffer.isBuffer(data)) {
+        return data.toString();
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data).toString();
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data).toString();
+    }
+    return String(data);
+}
+//# sourceMappingURL=message-utils.js.map

package/dist/src/backend/routers/websocket/message-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-utils.js","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/message-utils.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,eAAe,CAAC,IAAa;IAC3C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;IACxC,CAAC;IACD,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;QAChC,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC"}

package/dist/src/backend/routers/websocket/terminal.handler.d.ts

@@ -1,7 +1,9 @@
 import type { IncomingMessage } from 'node:http';
 import type { Duplex } from 'node:stream';
 import type { WebSocket, WebSocketServer } from 'ws';
+import { type AppContext } from '../../app-context.js';
 export type TerminalConnectionsMap = Map<string, Set<WebSocket>>;
 export declare const terminalConnections: TerminalConnectionsMap;
-export declare function handleTerminalUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer, url: URL, wss: WebSocketServer, wsAliveMap: WeakMap<WebSocket, boolean>): void;
+export declare function createTerminalUpgradeHandler(appContext: AppContext): (request: IncomingMessage, socket: Duplex, head: Buffer, url: URL, wss: WebSocketServer, wsAliveMap: WeakMap<WebSocket, boolean>) => void;
+export declare const handleTerminalUpgrade: (request: IncomingMessage, socket: Duplex, head: Buffer, url: URL, wss: WebSocketServer, wsAliveMap: WeakMap<WebSocket, boolean>) => void;
 //# sourceMappingURL=terminal.handler.d.ts.map

package/dist/src/backend/routers/websocket/terminal.handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal.handler.d.ts","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/terminal.handler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAiBrD,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;AAMjE,eAAO,MAAM,mBAAmB,EAAE,sBAAkC,CAAC;AA2BrE,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,eAAe,EACpB,UAAU,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,GACtC,IAAI,CAuTN"}
+{"version":3,"file":"terminal.handler.d.ts","sourceRoot":"","sources":["../../../../../src/backend/routers/websocket/terminal.handler.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AACrD,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,mBAAmB,CAAC;AActE,MAAM,MAAM,sBAAsB,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;AAMjE,eAAO,MAAM,mBAAmB,EAAE,sBAAkC,CAAC;AA6VrE,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,UAAU,IAK/D,SAAS,eAAe,EACxB,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,KAAK,GAAG,EACR,KAAK,eAAe,EACpB,YAAY,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,KACtC,IAAI,CAuER;AAED,eAAO,MAAM,qBAAqB,YA/ErB,eAAe,UAChB,MAAM,QACR,MAAM,OACP,GAAG,OACH,eAAe,cACR,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,KACtC,IAyEgF,CAAC"}

package/dist/src/backend/routers/websocket/terminal.handler.js

@@ -1,13 +1,12 @@
+import { createAppContext } from '../../app-context.js';
 import { WS_READY_STATE } from '../../constants/index.js';
 import { terminalSessionAccessor } from '../../resource_accessors/terminal-session.accessor.js';
 import { workspaceAccessor } from '../../resource_accessors/workspace.accessor.js';
 import { TerminalMessageSchema } from '../../schemas/websocket/index.js';
-import { createLogger } from '../../services/index.js';
-import { terminalService } from '../../services/terminal.service.js';
-const logger = createLogger('terminal-handler');
+import { toMessageString } from './message-utils.js';
 export const terminalConnections = new Map();
 const terminalListenerCleanup = new WeakMap();
-function cleanupTerminalListeners(ws) {
+function cleanupTerminalListeners(ws, logger) {
     const cleanupMap = terminalListenerCleanup.get(ws);
     if (!cleanupMap) {
         return;
@@ -20,265 +19,307 @@ function cleanupTerminalListeners(ws) {
     }
     cleanupMap.clear();
 }
-export function handleTerminalUpgrade(request, socket, head, url, wss, wsAliveMap) {
-    const workspaceId = url.searchParams.get('workspaceId');
-    if (!workspaceId) {
-        logger.warn('Terminal WebSocket missing workspaceId');
-        socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
-        socket.destroy();
+function ensureWorkspaceConnections(workspaceId) {
+    if (!terminalConnections.has(workspaceId)) {
+        terminalConnections.set(workspaceId, new Set());
+    }
+    return terminalConnections.get(workspaceId);
+}
+function addTerminalCleanupMap(ws) {
+    const cleanupMap = new Map();
+    terminalListenerCleanup.set(ws, cleanupMap);
+    return cleanupMap;
+}
+function sendInitialStatus(ws, workspaceId, logger) {
+    logger.debug('Sending initial status message', { workspaceId });
+    ws.send(JSON.stringify({ type: 'status', connected: true }));
+}
+function sendExistingTerminals(ws, workspaceId, terminalService, logger) {
+    const existingTerminals = terminalService.getTerminalsForWorkspace(workspaceId);
+    if (existingTerminals.length === 0) {
         return;
     }
-    wss.handleUpgrade(request, socket, head, (ws) => {
-        logger.info('Terminal WebSocket connection established', { workspaceId });
-        wsAliveMap.set(ws, true);
-        ws.on('pong', () => wsAliveMap.set(ws, true));
-        if (!terminalConnections.has(workspaceId)) {
-            terminalConnections.set(workspaceId, new Set());
+    logger.info('Sending existing terminal list for restoration', {
+        workspaceId,
+        terminalCount: existingTerminals.length,
+    });
+    ws.send(JSON.stringify({
+        type: 'terminal_list',
+        terminals: existingTerminals.map((t) => ({
+            id: t.id,
+            createdAt: t.createdAt.toISOString(),
+            outputBuffer: t.outputBuffer,
+        })),
+    }));
+    const existingConnections = terminalConnections.get(workspaceId);
+    if (existingConnections) {
+        for (const existingWs of existingConnections) {
+            if (existingWs !== ws) {
+                logger.debug('Cleaning up listeners from existing connection', { workspaceId });
+                cleanupTerminalListeners(existingWs, logger);
+            }
         }
-        terminalConnections.get(workspaceId)?.add(ws);
-        terminalListenerCleanup.set(ws, new Map());
-        logger.debug('Sending initial status message', { workspaceId });
-        ws.send(JSON.stringify({ type: 'status', connected: true }));
-        const existingTerminals = terminalService.getTerminalsForWorkspace(workspaceId);
-        if (existingTerminals.length > 0) {
-            logger.info('Sending existing terminal list for restoration', {
+    }
+    const cleanupMap = terminalListenerCleanup.get(ws);
+    for (const terminal of existingTerminals) {
+        const unsubscribers = [];
+        if (cleanupMap) {
+            cleanupMap.set(terminal.id, unsubscribers);
+        }
+        const unsubOutput = terminalService.onOutput(terminal.id, (output) => {
+            if (ws.readyState === WS_READY_STATE.OPEN) {
+                ws.send(JSON.stringify({ type: 'output', terminalId: terminal.id, data: output }));
+            }
+        });
+        unsubscribers.push(unsubOutput);
+        const unsubExit = terminalService.onExit(terminal.id, (exitCode) => {
+            logger.info('Terminal process exited', { terminalId: terminal.id, exitCode });
+            if (ws.readyState === WS_READY_STATE.OPEN) {
+                ws.send(JSON.stringify({ type: 'exit', terminalId: terminal.id, exitCode }));
+            }
+            const exitCleanupMap = terminalListenerCleanup.get(ws);
+            if (exitCleanupMap) {
+                exitCleanupMap.delete(terminal.id);
+            }
+            terminalSessionAccessor.clearPid(terminal.id).catch((err) => {
+                logger.warn('Failed to clear terminal PID', { terminalId: terminal.id, error: err });
+            });
+        });
+        unsubscribers.push(unsubExit);
+    }
+}
+function parseTerminalMessage(workspaceId, data, logger) {
+    const rawMessage = JSON.parse(toMessageString(data));
+    const parseResult = TerminalMessageSchema.safeParse(rawMessage);
+    if (!parseResult.success) {
+        logger.warn('Invalid terminal message format', {
+            workspaceId,
+            errors: parseResult.error.issues,
+        });
+        return null;
+    }
+    return parseResult.data;
+}
+function sendSocketError(ws, message) {
+    if (ws.readyState === WS_READY_STATE.OPEN) {
+        ws.send(JSON.stringify({ type: 'error', message }));
+    }
+}
+async function handleCreateMessage(ws, workspaceId, message, terminalService, logger) {
+    logger.info('Creating terminal', {
+        workspaceId,
+        cols: message.cols,
+        rows: message.rows,
+    });
+    const workspace = await workspaceAccessor.findById(workspaceId);
+    if (!workspace?.worktreePath) {
+        logger.warn('Workspace not found or has no worktree', { workspaceId });
+        sendSocketError(ws, 'Workspace not found or has no worktree');
+        return;
+    }
+    logger.info('Creating terminal with worktree', {
+        workspaceId,
+        worktreePath: workspace.worktreePath,
+    });
+    const { terminalId, pid } = await terminalService.createTerminal({
+        workspaceId,
+        workingDir: workspace.worktreePath,
+        cols: message.cols ?? 80,
+        rows: message.rows ?? 24,
+    });
+    await terminalSessionAccessor.create({
+        workspaceId,
+        name: terminalId,
+        pid,
+    });
+    const cleanupMap = terminalListenerCleanup.get(ws);
+    const unsubscribers = [];
+    if (cleanupMap) {
+        cleanupMap.set(terminalId, unsubscribers);
+    }
+    logger.debug('Setting up output forwarding', { terminalId });
+    const unsubOutput = terminalService.onOutput(terminalId, (output) => {
+        if (ws.readyState === WS_READY_STATE.OPEN) {
+            logger.debug('Forwarding output to client', {
+                terminalId,
+                outputLen: output.length,
+            });
+            ws.send(JSON.stringify({ type: 'output', terminalId, data: output }));
+        }
+        else {
+            logger.warn('Cannot forward output - WebSocket not open', {
+                terminalId,
+                readyState: ws.readyState,
+            });
+        }
+    });
+    unsubscribers.push(unsubOutput);
+    const unsubExit = terminalService.onExit(terminalId, (exitCode) => {
+        logger.info('Terminal process exited', { terminalId, exitCode });
+        if (ws.readyState === WS_READY_STATE.OPEN) {
+            ws.send(JSON.stringify({ type: 'exit', terminalId, exitCode }));
+        }
+        const exitCleanupMap = terminalListenerCleanup.get(ws);
+        if (exitCleanupMap) {
+            exitCleanupMap.delete(terminalId);
+        }
+        terminalSessionAccessor.clearPid(terminalId).catch((err) => {
+            logger.warn('Failed to clear terminal PID', { terminalId, error: err });
+        });
+    });
+    unsubscribers.push(unsubExit);
+    logger.info('Sending created message to client', { terminalId });
+    ws.send(JSON.stringify({ type: 'created', terminalId }));
+}
+function handleInputMessage(workspaceId, message, terminalService, logger) {
+    if (message.terminalId && message.data) {
+        logger.debug('Writing input to terminal', {
+            terminalId: message.terminalId,
+            dataLen: message.data.length,
+        });
+        const success = terminalService.writeToTerminal(workspaceId, message.terminalId, message.data);
+        if (!success) {
+            logger.warn('Failed to write to terminal', {
                 workspaceId,
-                terminalCount: existingTerminals.length,
+                terminalId: message.terminalId,
             });
-            ws.send(JSON.stringify({
-                type: 'terminal_list',
-                terminals: existingTerminals.map((t) => ({
-                    id: t.id,
-                    createdAt: t.createdAt.toISOString(),
-                    outputBuffer: t.outputBuffer,
-                })),
-            }));
-            const existingConnections = terminalConnections.get(workspaceId);
-            if (existingConnections) {
-                for (const existingWs of existingConnections) {
-                    if (existingWs !== ws) {
-                        logger.debug('Cleaning up listeners from existing connection', { workspaceId });
-                        cleanupTerminalListeners(existingWs);
-                    }
-                }
-            }
-            const cleanupMap = terminalListenerCleanup.get(ws);
-            for (const terminal of existingTerminals) {
-                const unsubscribers = [];
-                if (cleanupMap) {
-                    cleanupMap.set(terminal.id, unsubscribers);
-                }
-                const unsubOutput = terminalService.onOutput(terminal.id, (output) => {
-                    if (ws.readyState === WS_READY_STATE.OPEN) {
-                        ws.send(JSON.stringify({ type: 'output', terminalId: terminal.id, data: output }));
-                    }
-                });
-                unsubscribers.push(unsubOutput);
-                const unsubExit = terminalService.onExit(terminal.id, (exitCode) => {
-                    logger.info('Terminal process exited', { terminalId: terminal.id, exitCode });
-                    if (ws.readyState === WS_READY_STATE.OPEN) {
-                        ws.send(JSON.stringify({ type: 'exit', terminalId: terminal.id, exitCode }));
-                    }
-                    const exitCleanupMap = terminalListenerCleanup.get(ws);
-                    if (exitCleanupMap) {
-                        exitCleanupMap.delete(terminal.id);
-                    }
-                    terminalSessionAccessor.clearPid(terminal.id).catch((err) => {
-                        logger.warn('Failed to clear terminal PID', { terminalId: terminal.id, error: err });
-                    });
-                });
-                unsubscribers.push(unsubExit);
+        }
+    }
+    else {
+        logger.warn('Input message missing terminalId or data', { message });
+    }
+}
+function handleResizeMessage(workspaceId, message, terminalService, logger) {
+    if (message.terminalId && message.cols && message.rows) {
+        logger.debug('Resizing terminal', {
+            terminalId: message.terminalId,
+            cols: message.cols,
+            rows: message.rows,
+        });
+        terminalService.resizeTerminal(workspaceId, message.terminalId, message.cols, message.rows);
+    }
+    else {
+        logger.warn('Resize message missing required fields', { message });
+    }
+}
+function handleDestroyMessage(ws, workspaceId, message, terminalService, logger) {
+    if (message.terminalId) {
+        logger.info('Destroying terminal', { terminalId: message.terminalId });
+        const cleanupMap = terminalListenerCleanup.get(ws);
+        const unsubs = cleanupMap?.get(message.terminalId);
+        if (unsubs) {
+            for (const unsub of unsubs) {
+                unsub();
             }
+            cleanupMap?.delete(message.terminalId);
         }
-        ws.on('message', async (data) => {
-            try {
-                const rawMessage = JSON.parse(data.toString());
-                const parseResult = TerminalMessageSchema.safeParse(rawMessage);
-                if (!parseResult.success) {
-                    logger.warn('Invalid terminal message format', {
+        terminalService.destroyTerminal(workspaceId, message.terminalId);
+    }
+}
+function handleSetActiveMessage(workspaceId, message, terminalService, logger) {
+    if (message.terminalId) {
+        logger.debug('Setting active terminal', {
+            workspaceId,
+            terminalId: message.terminalId,
+        });
+        terminalService.setActiveTerminal(workspaceId, message.terminalId);
+    }
+}
+function handlePingMessage(ws) {
+    if (ws.readyState === WS_READY_STATE.OPEN) {
+        ws.send(JSON.stringify({ type: 'pong' }));
+    }
+}
+async function handleTerminalMessage(ws, workspaceId, data, terminalService, logger) {
+    const message = parseTerminalMessage(workspaceId, data, logger);
+    if (!message) {
+        sendSocketError(ws, 'Invalid message format');
+        return;
+    }
+    logger.debug('Received terminal message', {
+        workspaceId,
+        type: message.type,
+        terminalId: 'terminalId' in message ? message.terminalId : undefined,
+    });
+    switch (message.type) {
+        case 'create':
+            await handleCreateMessage(ws, workspaceId, message, terminalService, logger);
+            break;
+        case 'input':
+            handleInputMessage(workspaceId, message, terminalService, logger);
+            break;
+        case 'resize':
+            handleResizeMessage(workspaceId, message, terminalService, logger);
+            break;
+        case 'destroy':
+            handleDestroyMessage(ws, workspaceId, message, terminalService, logger);
+            break;
+        case 'set_active':
+            handleSetActiveMessage(workspaceId, message, terminalService, logger);
+            break;
+        case 'ping':
+            handlePingMessage(ws);
+            break;
+    }
+}
+export function createTerminalUpgradeHandler(appContext) {
+    const terminalService = appContext.services.terminalService;
+    const logger = appContext.services.createLogger('terminal-handler');
+    return function handleTerminalUpgrade(request, socket, head, url, wss, wsAliveMap) {
+        const workspaceId = url.searchParams.get('workspaceId');
+        if (!workspaceId) {
+            logger.warn('Terminal WebSocket missing workspaceId');
+            socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            logger.info('Terminal WebSocket connection established', { workspaceId });
+            wsAliveMap.set(ws, true);
+            ws.on('pong', () => wsAliveMap.set(ws, true));
+            ensureWorkspaceConnections(workspaceId).add(ws);
+            addTerminalCleanupMap(ws);
+            sendInitialStatus(ws, workspaceId, logger);
+            sendExistingTerminals(ws, workspaceId, terminalService, logger);
+            ws.on('message', async (data) => {
+                try {
+                    await handleTerminalMessage(ws, workspaceId, data, terminalService, logger);
+                }
+                catch (error) {
+                    const err = error;
+                    const isParsError = err instanceof SyntaxError;
+                    const errorMessage = isParsError
+                        ? 'Invalid message format'
+                        : `Operation failed: ${err.message}`;
+                    logger.error('Error handling terminal message', err, {
                         workspaceId,
-                        errors: parseResult.error.issues,
+                        isParsError,
                     });
                     if (ws.readyState === WS_READY_STATE.OPEN) {
-                        ws.send(JSON.stringify({ type: 'error', message: 'Invalid message format' }));
+                        ws.send(JSON.stringify({ type: 'error', message: errorMessage }));
                     }
-                    return;
                 }
-                const message = parseResult.data;
-                logger.debug('Received terminal message', {
-                    workspaceId,
-                    type: message.type,
-                    terminalId: 'terminalId' in message ? message.terminalId : undefined,
-                });
-                switch (message.type) {
-                    case 'create': {
-                        logger.info('Creating terminal', {
-                            workspaceId,
-                            cols: message.cols,
-                            rows: message.rows,
-                        });
-                        const workspace = await workspaceAccessor.findById(workspaceId);
-                        if (!workspace?.worktreePath) {
-                            logger.warn('Workspace not found or has no worktree', { workspaceId });
-                            ws.send(JSON.stringify({
-                                type: 'error',
-                                message: 'Workspace not found or has no worktree',
-                            }));
-                            return;
-                        }
-                        logger.info('Creating terminal with worktree', {
-                            workspaceId,
-                            worktreePath: workspace.worktreePath,
-                        });
-                        const { terminalId, pid } = await terminalService.createTerminal({
-                            workspaceId,
-                            workingDir: workspace.worktreePath,
-                            cols: message.cols ?? 80,
-                            rows: message.rows ?? 24,
-                        });
-                        await terminalSessionAccessor.create({
+            });
+            ws.on('close', () => {
+                logger.info('Terminal WebSocket connection closed', { workspaceId });
+                cleanupTerminalListeners(ws, logger);
+                const connections = terminalConnections.get(workspaceId);
+                if (connections) {
+                    connections.delete(ws);
+                    if (connections.size === 0) {
+                        terminalConnections.delete(workspaceId);
+                        logger.info('All WebSocket connections closed for workspace', {
                             workspaceId,
-                            name: terminalId,
-                            pid,
+                            message: 'Terminals will persist until explicitly closed or workspace is archived/deleted',
                         });
-                        const cleanupMap = terminalListenerCleanup.get(ws);
-                        const unsubscribers = [];
-                        if (cleanupMap) {
-                            cleanupMap.set(terminalId, unsubscribers);
-                        }
-                        logger.debug('Setting up output forwarding', { terminalId });
-                        const unsubOutput = terminalService.onOutput(terminalId, (output) => {
-                            if (ws.readyState === WS_READY_STATE.OPEN) {
-                                logger.debug('Forwarding output to client', {
-                                    terminalId,
-                                    outputLen: output.length,
-                                });
-                                ws.send(JSON.stringify({ type: 'output', terminalId, data: output }));
-                            }
-                            else {
-                                logger.warn('Cannot forward output - WebSocket not open', {
-                                    terminalId,
-                                    readyState: ws.readyState,
-                                });
-                            }
-                        });
-                        unsubscribers.push(unsubOutput);
-                        const unsubExit = terminalService.onExit(terminalId, (exitCode) => {
-                            logger.info('Terminal process exited', { terminalId, exitCode });
-                            if (ws.readyState === WS_READY_STATE.OPEN) {
-                                ws.send(JSON.stringify({ type: 'exit', terminalId, exitCode }));
-                            }
-                            const exitCleanupMap = terminalListenerCleanup.get(ws);
-                            if (exitCleanupMap) {
-                                exitCleanupMap.delete(terminalId);
-                            }
-                            terminalSessionAccessor.clearPid(terminalId).catch((err) => {
-                                logger.warn('Failed to clear terminal PID', { terminalId, error: err });
-                            });
-                        });
-                        unsubscribers.push(unsubExit);
-                        logger.info('Sending created message to client', { terminalId });
-                        ws.send(JSON.stringify({ type: 'created', terminalId }));
-                        break;
-                    }
-                    case 'input': {
-                        if (message.terminalId && message.data) {
-                            logger.debug('Writing input to terminal', {
-                                terminalId: message.terminalId,
-                                dataLen: message.data.length,
-                            });
-                            const success = terminalService.writeToTerminal(workspaceId, message.terminalId, message.data);
-                            if (!success) {
-                                logger.warn('Failed to write to terminal', {
-                                    workspaceId,
-                                    terminalId: message.terminalId,
-                                });
-                            }
-                        }
-                        else {
-                            logger.warn('Input message missing terminalId or data', { message });
-                        }
-                        break;
-                    }
-                    case 'resize': {
-                        if (message.terminalId && message.cols && message.rows) {
-                            logger.debug('Resizing terminal', {
-                                terminalId: message.terminalId,
-                                cols: message.cols,
-                                rows: message.rows,
-                            });
-                            terminalService.resizeTerminal(workspaceId, message.terminalId, message.cols, message.rows);
-                        }
-                        else {
-                            logger.warn('Resize message missing required fields', { message });
-                        }
-                        break;
-                    }
-                    case 'destroy': {
-                        if (message.terminalId) {
-                            logger.info('Destroying terminal', { terminalId: message.terminalId });
-                            const cleanupMap = terminalListenerCleanup.get(ws);
-                            const unsubs = cleanupMap?.get(message.terminalId);
-                            if (unsubs) {
-                                for (const unsub of unsubs) {
-                                    unsub();
-                                }
-                                cleanupMap?.delete(message.terminalId);
-                            }
-                            terminalService.destroyTerminal(workspaceId, message.terminalId);
-                        }
-                        break;
-                    }
-                    case 'set_active': {
-                        if (message.terminalId) {
-                            logger.debug('Setting active terminal', {
-                                workspaceId,
-                                terminalId: message.terminalId,
-                            });
-                            terminalService.setActiveTerminal(workspaceId, message.terminalId);
-                        }
-                        break;
                     }
-                    case 'ping':
-                        if (ws.readyState === WS_READY_STATE.OPEN) {
-                            ws.send(JSON.stringify({ type: 'pong' }));
-                        }
-                        break;
                 }
-            }
-            catch (error) {
-                const err = error;
-                const isParsError = err instanceof SyntaxError;
-                const errorMessage = isParsError
-                    ? 'Invalid message format'
-                    : `Operation failed: ${err.message}`;
-                logger.error('Error handling terminal message', err, {
-                    workspaceId,
-                    isParsError,
-                });
-                if (ws.readyState === WS_READY_STATE.OPEN) {
-                    ws.send(JSON.stringify({ type: 'error', message: errorMessage }));
-                }
-            }
-        });
-        ws.on('close', () => {
-            logger.info('Terminal WebSocket connection closed', { workspaceId });
-            cleanupTerminalListeners(ws);
-            const connections = terminalConnections.get(workspaceId);
-            if (connections) {
-                connections.delete(ws);
-                if (connections.size === 0) {
-                    terminalConnections.delete(workspaceId);
-                    logger.info('All WebSocket connections closed for workspace', {
-                        workspaceId,
-                        message: 'Terminals will persist until explicitly closed or workspace is archived/deleted',
-                    });
-                }
-            }
-        });
-        ws.on('error', (error) => {
-            logger.error('Terminal WebSocket error', error);
+            });
+            ws.on('error', (error) => {
+                logger.error('Terminal WebSocket error', error);
+            });
         });
-    });
+    };
 }
+export const handleTerminalUpgrade = createTerminalUpgradeHandler(createAppContext());
 //# sourceMappingURL=terminal.handler.js.map