crewly 1.0.0

package/dist/backend/backend/src/websocket/terminal.gateway.js

@@ -0,0 +1,980 @@
+/**
+ * Terminal Gateway Module
+ *
+ * Provides WebSocket-based real-time terminal streaming for PTY sessions.
+ * Uses event-based streaming instead of polling for better performance.
+ *
+ * @module terminal-gateway
+ */
+import { LoggerService } from '../services/core/logger.service.js';
+import { getSessionBackendSync, } from '../services/session/index.js';
+import { getChatGateway } from './chat.gateway.js';
+import { ORCHESTRATOR_SESSION_NAME, CHAT_CONSTANTS, NOTIFY_CONSTANTS, SLACK_NOTIFY_CONSTANTS } from '../constants.js';
+import { getSlackOrchestratorBridge } from '../services/slack/slack-orchestrator-bridge.js';
+import { getChatService } from '../services/chat/chat.service.js';
+import { stripAnsiCodes, generateResponseHash, ResponseDeduplicator } from '../utils/terminal-output.utils.js';
+import { parseNotifyContent } from '../types/chat.types.js';
+import { PtyActivityTrackerService } from '../services/agent/pty-activity-tracker.service.js';
+/**
+ * Terminal Gateway class for WebSocket-based terminal streaming.
+ *
+ * Provides:
+ * - Real-time terminal output streaming via PTY onData events
+ * - Terminal input forwarding to PTY sessions
+ * - Terminal resize handling
+ * - Session subscription management
+ */
+export class TerminalGateway {
+    io;
+    logger;
+    /** Map of session name to set of subscribed socket IDs */
+    connectedClients = new Map();
+    /** Map of session name to unsubscribe function for PTY onData */
+    sessionSubscriptions = new Map();
+    /** Set of sessions with persistent monitoring (not stopped on client disconnect) */
+    persistentMonitoringSessions = new Set();
+    /** Current active chat conversation ID for orchestrator responses */
+    activeConversationId = null;
+    /** Buffer to accumulate orchestrator output for [NOTIFY] / legacy marker detection */
+    orchestratorOutputBuffer = '';
+    /** Maximum buffer size to prevent memory issues (100KB) */
+    MAX_BUFFER_SIZE = 100 * 1024;
+    /** Deduplicator for recently sent chat responses */
+    responseDeduplicator = new ResponseDeduplicator();
+    /**
+     * Create a new TerminalGateway.
+     *
+     * @param io - Socket.IO server instance
+     */
+    constructor(io) {
+        this.io = io;
+        this.logger = LoggerService.getInstance().createComponentLogger('TerminalGateway');
+        this.setupEventHandlers();
+    }
+    /**
+     * Set up WebSocket event handlers.
+     */
+    setupEventHandlers() {
+        this.io.on('connection', (socket) => {
+            this.logger.info('WebSocket client connected', { socketId: socket.id });
+            // Handle subscription to terminal sessions
+            socket.on('subscribe_to_session', (sessionName) => {
+                this.logger.debug('Received subscribe_to_session event', {
+                    sessionName,
+                    socketId: socket.id,
+                });
+                this.subscribeToSession(sessionName, socket);
+            });
+            // Handle unsubscription from terminal sessions
+            socket.on('unsubscribe_from_session', (sessionName) => {
+                this.unsubscribeFromSession(sessionName, socket);
+            });
+            // Handle sending input to terminal sessions
+            socket.on('send_input', async (data) => {
+                await this.sendInput(data.sessionName, data.input, socket);
+            });
+            // Handle terminal resize events
+            socket.on('terminal_resize', (data) => {
+                this.handleTerminalResize(data.sessionName, data.cols, data.rows);
+            });
+            // Handle client disconnection
+            socket.on('disconnect', () => {
+                this.handleClientDisconnect(socket);
+            });
+            // Send initial connection confirmation
+            socket.emit('connected', {
+                type: 'connection_established',
+                payload: { socketId: socket.id },
+                timestamp: new Date().toISOString(),
+            });
+        });
+    }
+    /**
+     * Subscribe a client to a specific terminal session.
+     *
+     * @param sessionName - The session to subscribe to
+     * @param socket - The client socket
+     */
+    subscribeToSession(sessionName, socket) {
+        this.logger.info('Subscribing client to session', {
+            socketId: socket.id,
+            sessionName,
+        });
+        // Initialize client set for this session if not exists
+        if (!this.connectedClients.has(sessionName)) {
+            this.connectedClients.set(sessionName, new Set());
+        }
+        // Add client to subscription list
+        this.connectedClients.get(sessionName).add(socket.id);
+        // Join socket.io room for this session
+        socket.join(`terminal_${sessionName}`);
+        // Start PTY output streaming if not already started
+        const streamingStarted = this.startPtyStreaming(sessionName);
+        // Send current terminal state to new subscriber
+        this.sendCurrentTerminalState(sessionName, socket);
+        // Confirm subscription (even if session doesn't exist yet - client will get updates when it's created)
+        socket.emit('subscription_confirmed', {
+            type: 'subscription_confirmed',
+            payload: { sessionName, sessionExists: streamingStarted },
+            timestamp: new Date().toISOString(),
+        });
+        // If session doesn't exist, also emit a session_not_found so client knows to wait
+        if (!streamingStarted) {
+            this.logger.info('Session does not exist yet, client will wait for creation', {
+                sessionName,
+                socketId: socket.id,
+            });
+            socket.emit('session_pending', {
+                type: 'session_pending',
+                payload: { sessionName, message: 'Session is being created, please wait...' },
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Start streaming output from a PTY session.
+     * Uses event-based onData instead of polling.
+     *
+     * @param sessionName - The session to stream from
+     * @returns True if streaming started successfully, false otherwise
+     */
+    startPtyStreaming(sessionName) {
+        // Don't duplicate subscriptions
+        if (this.sessionSubscriptions.has(sessionName)) {
+            this.logger.debug('Session already has streaming subscription', { sessionName });
+            return true;
+        }
+        const backend = getSessionBackendSync();
+        if (!backend) {
+            this.logger.warn('Session backend not initialized, cannot start streaming', {
+                sessionName,
+            });
+            return false;
+        }
+        // List all available sessions for debugging
+        const availableSessions = backend.listSessions();
+        this.logger.debug('Looking for session in backend', {
+            sessionName,
+            availableSessions,
+            sessionCount: availableSessions.length,
+        });
+        const session = backend.getSession(sessionName);
+        if (!session) {
+            this.logger.warn('Session not found for streaming', {
+                sessionName,
+                availableSessions,
+            });
+            return false;
+        }
+        // Subscribe to PTY onData events - real-time streaming
+        const unsubscribeData = session.onData((data) => {
+            // Record activity for idle detection
+            PtyActivityTrackerService.getInstance().recordActivity(sessionName);
+            const terminalOutput = {
+                sessionName,
+                content: data,
+                timestamp: new Date().toISOString(),
+                type: 'stdout',
+            };
+            this.broadcastOutput(sessionName, terminalOutput);
+        });
+        // Subscribe to exit events
+        const unsubscribeExit = session.onExit((exitCode) => {
+            this.logger.info('Session exited', { sessionName, exitCode });
+            this.broadcastSessionStatus(sessionName, 'terminated');
+            this.cleanupSessionSubscription(sessionName);
+        });
+        // Store combined cleanup function to prevent memory leaks
+        this.sessionSubscriptions.set(sessionName, () => {
+            unsubscribeData();
+            unsubscribeExit();
+        });
+        this.logger.info('Started PTY streaming for session', { sessionName });
+        return true;
+    }
+    /**
+     * Stop streaming output from a PTY session.
+     * Does not stop sessions with persistent monitoring enabled.
+     *
+     * @param sessionName - The session to stop streaming from
+     * @param force - Force stop even for persistent monitoring sessions
+     */
+    stopPtyStreaming(sessionName, force = false) {
+        // Don't stop persistent monitoring sessions unless forced
+        if (!force && this.persistentMonitoringSessions.has(sessionName)) {
+            this.logger.debug('Skipping stop for persistent monitoring session', { sessionName });
+            return;
+        }
+        const unsubscribe = this.sessionSubscriptions.get(sessionName);
+        if (unsubscribe) {
+            unsubscribe();
+            this.sessionSubscriptions.delete(sessionName);
+            this.persistentMonitoringSessions.delete(sessionName);
+            this.logger.info('Stopped PTY streaming for session', { sessionName });
+        }
+    }
+    /**
+     * Start persistent monitoring for the orchestrator session.
+     * This ensures chat responses are captured even when no WebSocket clients are viewing the terminal.
+     *
+     * @param sessionName - The orchestrator session name to monitor
+     * @returns True if monitoring started successfully
+     */
+    startOrchestratorChatMonitoring(sessionName) {
+        this.logger.info('Starting persistent orchestrator chat monitoring', { sessionName });
+        // Force cleanup any stale subscription from a previous session.
+        // When the orchestrator is restarted, the old PTY session is destroyed but
+        // the subscription entry may still exist pointing to the dead session.
+        // We must remove it so startPtyStreaming creates a fresh subscription.
+        if (this.sessionSubscriptions.has(sessionName)) {
+            this.logger.info('Cleaning up existing subscription for orchestrator chat monitoring', { sessionName });
+            const unsubscribe = this.sessionSubscriptions.get(sessionName);
+            unsubscribe();
+            this.sessionSubscriptions.delete(sessionName);
+        }
+        // Clear the output buffer and response hash cache for fresh monitoring
+        this.orchestratorOutputBuffer = '';
+        this.responseDeduplicator.clear();
+        // Mark session as persistent so it won't be stopped when clients disconnect
+        this.persistentMonitoringSessions.add(sessionName);
+        const started = this.startPtyStreaming(sessionName);
+        if (!started) {
+            this.logger.warn('Failed to start orchestrator chat monitoring', { sessionName });
+            this.persistentMonitoringSessions.delete(sessionName);
+        }
+        return started;
+    }
+    /**
+     * Stop persistent monitoring for the orchestrator session.
+     *
+     * @param sessionName - The orchestrator session name
+     */
+    stopOrchestratorChatMonitoring(sessionName) {
+        this.logger.info('Stopping persistent orchestrator chat monitoring', { sessionName });
+        this.stopPtyStreaming(sessionName, true);
+    }
+    /**
+     * Clean up session subscription when session ends.
+     *
+     * @param sessionName - The session to clean up
+     */
+    cleanupSessionSubscription(sessionName) {
+        this.stopPtyStreaming(sessionName);
+        this.connectedClients.delete(sessionName);
+    }
+    /**
+     * Unsubscribe a client from a terminal session.
+     *
+     * @param sessionName - The session to unsubscribe from
+     * @param socket - The client socket
+     */
+    unsubscribeFromSession(sessionName, socket) {
+        const clients = this.connectedClients.get(sessionName);
+        if (clients) {
+            clients.delete(socket.id);
+            // Stop streaming if no more clients watching
+            if (clients.size === 0) {
+                this.stopPtyStreaming(sessionName);
+                this.connectedClients.delete(sessionName);
+            }
+        }
+        // Leave socket.io room
+        socket.leave(`terminal_${sessionName}`);
+        this.logger.debug('Client unsubscribed from session', {
+            socketId: socket.id,
+            sessionName,
+        });
+        // Confirm unsubscription
+        socket.emit('unsubscription_confirmed', {
+            type: 'unsubscription_confirmed',
+            payload: { sessionName },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Send input to a terminal session.
+     *
+     * @param sessionName - The session to send input to
+     * @param input - The input string
+     * @param socket - The client socket
+     */
+    async sendInput(sessionName, input, socket) {
+        try {
+            const backend = getSessionBackendSync();
+            if (!backend) {
+                throw new Error('Session backend not initialized');
+            }
+            const session = backend.getSession(sessionName);
+            if (!session) {
+                socket.emit('error', {
+                    type: 'session_not_found',
+                    payload: { sessionName, error: 'Session does not exist' },
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            // Write input directly to PTY
+            session.write(input);
+            this.logger.debug('Sent input to session', {
+                sessionName,
+                inputLength: input.length,
+                fromClient: socket.id,
+            });
+            // Broadcast input confirmation to all subscribers
+            this.broadcastMessage(sessionName, 'input_received', {
+                sessionName,
+                input,
+                fromClient: socket.id,
+            });
+        }
+        catch (error) {
+            this.logger.error('Error sending input to session', {
+                sessionName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            socket.emit('error', {
+                type: 'input_error',
+                payload: {
+                    sessionName,
+                    error: error instanceof Error ? error.message : 'Failed to send input',
+                },
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Handle terminal resize events.
+     *
+     * @param sessionName - The session to resize
+     * @param cols - New column count
+     * @param rows - New row count
+     */
+    handleTerminalResize(sessionName, cols, rows) {
+        try {
+            const backend = getSessionBackendSync();
+            if (!backend) {
+                this.logger.warn('Cannot resize: session backend not initialized');
+                return;
+            }
+            const session = backend.getSession(sessionName);
+            if (!session) {
+                this.logger.debug('Cannot resize: session not found', { sessionName });
+                return;
+            }
+            session.resize(cols, rows);
+            this.logger.debug('Terminal resized', { sessionName, cols, rows });
+            // Broadcast resize event to other clients viewing the same session
+            this.broadcastMessage(sessionName, 'terminal_resized', {
+                sessionName,
+                cols,
+                rows,
+            });
+        }
+        catch (error) {
+            this.logger.error('Error resizing terminal', {
+                sessionName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Handle client disconnection.
+     *
+     * @param socket - The disconnected client socket
+     */
+    handleClientDisconnect(socket) {
+        this.logger.info('Client disconnected', { socketId: socket.id });
+        // Remove client from all session subscriptions
+        for (const [sessionName, clients] of this.connectedClients.entries()) {
+            if (clients.has(socket.id)) {
+                clients.delete(socket.id);
+                // Stop streaming if no more clients watching
+                if (clients.size === 0) {
+                    this.stopPtyStreaming(sessionName);
+                    this.connectedClients.delete(sessionName);
+                }
+            }
+        }
+    }
+    /**
+     * Broadcast terminal output to all subscribers of a session.
+     * Also processes orchestrator output for chat responses.
+     *
+     * @param sessionName - The session name
+     * @param output - The terminal output
+     */
+    broadcastOutput(sessionName, output) {
+        const message = {
+            type: 'terminal_output',
+            payload: output,
+            timestamp: new Date().toISOString(),
+        };
+        this.io.to(`terminal_${sessionName}`).emit('terminal_output', message);
+        // Process orchestrator output for chat responses
+        if (sessionName === ORCHESTRATOR_SESSION_NAME) {
+            this.processOrchestratorOutputForChat(sessionName, output.content);
+        }
+    }
+    /**
+     * Process orchestrator terminal output for [NOTIFY], legacy [CHAT_RESPONSE],
+     * and legacy [SLACK_NOTIFY] markers.
+     *
+     * Buffers output, then runs the unified [NOTIFY] handler first, followed by
+     * legacy handlers for backward compatibility with orchestrators that haven't
+     * restarted yet.
+     *
+     * @param sessionName - The orchestrator session name
+     * @param content - The terminal output content
+     */
+    processOrchestratorOutputForChat(sessionName, content) {
+        const chatGateway = getChatGateway();
+        if (!chatGateway) {
+            this.logger.debug('Chat gateway not available for response processing');
+            return;
+        }
+        const cleanContent = stripAnsiCodes(content);
+        // Extract conversation ID from the output if present
+        // The format is [CHAT:conversationId] at the start of a response
+        const chatIdMatch = cleanContent.match(CHAT_CONSTANTS.CONVERSATION_ID_PATTERN);
+        if (chatIdMatch) {
+            this.logger.debug('Extracted conversation ID from output', { conversationId: chatIdMatch[1] });
+            this.activeConversationId = chatIdMatch[1];
+        }
+        // Always buffer content — notifications don't require a conversation ID
+        this.orchestratorOutputBuffer += cleanContent;
+        // Prevent buffer from growing too large
+        if (this.orchestratorOutputBuffer.length > this.MAX_BUFFER_SIZE) {
+            this.orchestratorOutputBuffer = this.orchestratorOutputBuffer.slice(-this.MAX_BUFFER_SIZE / 2);
+        }
+        // Process unified [NOTIFY] markers first (preferred format)
+        this.processNotifyMarkers(sessionName);
+        // Process legacy [CHAT_RESPONSE] markers for backward compatibility
+        this.processLegacyChatResponse(sessionName);
+        // Process legacy [SLACK_NOTIFY] markers for backward compatibility
+        this.processLegacySlackNotifications();
+        this.trimBufferIfNoOpenMarkers();
+    }
+    /**
+     * Build a SlackNotification from a NotifyPayload.
+     *
+     * @param payload - Parsed notify payload
+     * @returns SlackNotification with defaults applied
+     */
+    buildSlackNotification(payload) {
+        return {
+            type: (payload.type || 'alert'),
+            title: payload.title || payload.type || 'Notification',
+            message: payload.message,
+            urgency: payload.urgency || 'normal',
+            timestamp: new Date().toISOString(),
+            channelId: payload.channelId,
+            threadTs: payload.threadTs,
+        };
+    }
+    /**
+     * Send a notification to the Slack bridge with error handling.
+     *
+     * @param notification - The Slack notification to send
+     * @param context - Description of the call site for logging
+     */
+    sendToSlackBridge(notification, context) {
+        const bridge = getSlackOrchestratorBridge();
+        if (bridge.isInitialized()) {
+            this.logger.info(`Routing ${context} to Slack`, {
+                type: notification.type,
+                channelId: notification.channelId,
+            });
+            bridge.sendNotification(notification).catch((error) => {
+                this.logger.warn(`Failed to route ${context} to Slack`, {
+                    error: error instanceof Error ? error.message : String(error),
+                    type: notification.type,
+                });
+            });
+        }
+        else {
+            this.logger.warn(`Slack bridge not initialized, skipping ${context}`, {
+                type: notification.type,
+            });
+        }
+    }
+    /**
+     * Process unified [NOTIFY]...[/NOTIFY] markers from the orchestrator output buffer.
+     *
+     * Parses header+body (or legacy JSON) payload via `parseNotifyContent()` and
+     * routes to chat, Slack, or both based on which fields are present:
+     * - `conversationId` present → route to chat UI
+     * - `channelId` present → route to Slack
+     * - Both → both (common case)
+     * - Neither + activeConversationId exists → fallback to chat
+     * - `type` alone (no channelId) → chat only (type is metadata, not a routing signal)
+     *
+     * @param sessionName - The orchestrator session name
+     */
+    processNotifyMarkers(sessionName) {
+        if (!this.orchestratorOutputBuffer.includes(NOTIFY_CONSTANTS.OPEN_TAG)) {
+            return;
+        }
+        NOTIFY_CONSTANTS.MARKER_PATTERN.lastIndex = 0;
+        let match;
+        let lastMatchEnd = 0;
+        while ((match = NOTIFY_CONSTANTS.MARKER_PATTERN.exec(this.orchestratorOutputBuffer)) !== null) {
+            const rawContent = match[1].trim();
+            lastMatchEnd = match.index + match[0].length;
+            const payload = parseNotifyContent(rawContent);
+            if (!payload) {
+                this.logger.warn('Invalid or empty NOTIFY payload', {
+                    rawContent: rawContent.slice(0, 200),
+                });
+                continue;
+            }
+            this.logger.debug('Detected NOTIFY marker in orchestrator output', {
+                contentLength: payload.message.length,
+            });
+            // Fire-and-forget to keep PTY non-blocking
+            void this.handleNotifyPayload(sessionName, payload).catch(error => {
+                this.logger.warn('Error handling NOTIFY payload', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        // Remove processed NOTIFY blocks from buffer
+        if (lastMatchEnd > 0) {
+            this.orchestratorOutputBuffer = this.orchestratorOutputBuffer.slice(lastMatchEnd);
+        }
+    }
+    /**
+     * Handle a single parsed NOTIFY payload — route to chat and/or Slack.
+     *
+     * When a channelId is present, Slack delivery metadata is stored on the chat
+     * message with `slackDeliveryStatus: 'pending'`. On successful Slack delivery,
+     * the status is updated to `'delivered'`. On failure, the error and attempt count
+     * are recorded, and the reconciliation service will retry later.
+     *
+     * @param sessionName - The orchestrator session name
+     * @param payload - Parsed NOTIFY payload
+     */
+    async handleNotifyPayload(sessionName, payload) {
+        const conversationId = payload.conversationId || this.activeConversationId;
+        // Build metadata dict with NOTIFY fields for the chat message
+        const metadata = {};
+        if (payload.channelId) {
+            metadata.slackChannelId = payload.channelId;
+            metadata.slackDeliveryStatus = 'pending';
+            metadata.slackDeliveryAttempts = 0;
+            if (payload.threadTs)
+                metadata.slackThreadTs = payload.threadTs;
+        }
+        if (payload.type)
+            metadata.notifyType = payload.type;
+        if (payload.title)
+            metadata.notifyTitle = payload.title;
+        if (payload.urgency)
+            metadata.notifyUrgency = payload.urgency;
+        // Route to chat UI
+        let chatMessage = null;
+        if (conversationId) {
+            const responseHash = generateResponseHash(conversationId, payload.message);
+            if (!this.responseDeduplicator.isDuplicate(responseHash)) {
+                this.logger.info('Routing NOTIFY to chat', {
+                    conversationId,
+                    contentLength: payload.message.length,
+                });
+                const chatGateway = getChatGateway();
+                if (chatGateway) {
+                    chatMessage = await chatGateway.processNotifyMessage(sessionName, payload.message, conversationId, Object.keys(metadata).length > 0 ? metadata : undefined);
+                }
+            }
+            else {
+                this.logger.debug('Skipping duplicate NOTIFY chat message', {
+                    conversationId,
+                    contentLength: payload.message.length,
+                });
+            }
+        }
+        // Slack delivery is handled exclusively by the reply-slack skill
+        // (which calls /api/slack/send directly). Do NOT route NOTIFY payloads
+        // to Slack here — PTY re-renders cause duplicate detections with partial
+        // content, and the timing is unreliable (NOTIFY fires before the skill).
+        // NOTIFY is only for routing responses to the chat UI above.
+        if (payload.channelId) {
+            this.logger.debug('NOTIFY has channelId but Slack delivery is skill-handled, skipping', {
+                channelId: payload.channelId,
+                type: payload.type,
+            });
+            // Track that this channel+thread was handled by skill so the
+            // SlackBridge's sendSlackResponse fallback can skip its duplicate send.
+            const bridge = getSlackOrchestratorBridge();
+            if (bridge.isInitialized()) {
+                bridge.markDeliveredBySkill(payload.channelId, payload.threadTs);
+            }
+            // Mark delivery status on the chat message
+            if (chatMessage && conversationId) {
+                const chatService = getChatService();
+                await chatService.updateMessageMetadata(conversationId, chatMessage.id, {
+                    slackDeliveryStatus: 'delivered_by_skill',
+                    slackDeliveryAttemptedAt: new Date().toISOString(),
+                });
+            }
+        }
+    }
+    /**
+     * Trim the orchestrator output buffer if there are no pending open markers.
+     * Prevents unbounded growth when output doesn't contain any markers.
+     */
+    trimBufferIfNoOpenMarkers() {
+        const hasPendingMarker = this.orchestratorOutputBuffer.includes(NOTIFY_CONSTANTS.OPEN_TAG) ||
+            this.orchestratorOutputBuffer.includes('[CHAT_RESPONSE') ||
+            this.orchestratorOutputBuffer.includes(SLACK_NOTIFY_CONSTANTS.OPEN_TAG);
+        if (!hasPendingMarker) {
+            // Keep a small trailing buffer in case the tag is split across chunks
+            const lastNewline = this.orchestratorOutputBuffer.lastIndexOf('\n');
+            if (lastNewline > 1000) {
+                this.orchestratorOutputBuffer = this.orchestratorOutputBuffer.slice(lastNewline);
+            }
+        }
+    }
+    /**
+     * Process legacy [CHAT_RESPONSE]...[/CHAT_RESPONSE] markers from the buffer.
+     * @deprecated Use [NOTIFY] markers instead. Kept for backward compatibility.
+     *
+     * @param sessionName - The orchestrator session name
+     */
+    processLegacyChatResponse(sessionName) {
+        if (!this.activeConversationId) {
+            return;
+        }
+        if (!this.orchestratorOutputBuffer.includes('[CHAT_RESPONSE')) {
+            return;
+        }
+        this.logger.debug('Processing legacy [CHAT_RESPONSE] markers (deprecated — use [NOTIFY])');
+        const chatGateway = getChatGateway();
+        if (!chatGateway) {
+            return;
+        }
+        const responsePattern = /\[CHAT_RESPONSE(?::([^\]]*))?\]([\s\S]*?)\[\/CHAT_RESPONSE\]/g;
+        let match;
+        let lastMatchEnd = 0;
+        while ((match = responsePattern.exec(this.orchestratorOutputBuffer)) !== null) {
+            const embeddedConversationId = match[1] || null;
+            const responseContent = match[2].trim();
+            lastMatchEnd = match.index + match[0].length;
+            const conversationId = embeddedConversationId || this.activeConversationId;
+            if (!conversationId) {
+                continue;
+            }
+            const responseHash = generateResponseHash(conversationId, responseContent);
+            if (this.responseDeduplicator.isDuplicate(responseHash)) {
+                this.logger.debug('Skipping duplicate legacy chat response', {
+                    conversationId,
+                    contentLength: responseContent.length,
+                });
+                continue;
+            }
+            this.logger.info('Extracted legacy chat response from orchestrator output', {
+                contentLength: responseContent.length,
+                conversationId,
+                embeddedConversationId,
+            });
+            chatGateway.processTerminalOutput(sessionName, `[CHAT_RESPONSE]${responseContent}[/CHAT_RESPONSE]`, conversationId).catch(error => {
+                this.logger.warn('Failed to process legacy chat response', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
+        }
+        if (lastMatchEnd > 0) {
+            this.orchestratorOutputBuffer = this.orchestratorOutputBuffer.slice(lastMatchEnd);
+        }
+    }
+    /**
+     * Process legacy [SLACK_NOTIFY]...[/SLACK_NOTIFY] markers from the buffer.
+     * @deprecated Use [NOTIFY] markers instead. Kept for backward compatibility.
+     */
+    processLegacySlackNotifications() {
+        if (!this.orchestratorOutputBuffer.includes(SLACK_NOTIFY_CONSTANTS.OPEN_TAG)) {
+            return;
+        }
+        this.logger.debug('Processing legacy [SLACK_NOTIFY] markers (deprecated — use [NOTIFY])');
+        SLACK_NOTIFY_CONSTANTS.MARKER_PATTERN.lastIndex = 0;
+        let match;
+        let lastMatchEnd = 0;
+        while ((match = SLACK_NOTIFY_CONSTANTS.MARKER_PATTERN.exec(this.orchestratorOutputBuffer)) !== null) {
+            const rawContent = match[1].trim();
+            lastMatchEnd = match.index + match[0].length;
+            // Legacy SLACK_NOTIFY is always JSON — use parseNotifyContent which
+            // auto-detects JSON and applies PTY cleanup
+            const payload = parseNotifyContent(rawContent);
+            if (!payload) {
+                this.logger.warn('Invalid legacy SLACK_NOTIFY payload', {
+                    rawContent: rawContent.slice(0, 200),
+                });
+                continue;
+            }
+            // Legacy format required `type` — skip if missing
+            if (!payload.type) {
+                this.logger.warn('Invalid legacy SLACK_NOTIFY payload: missing type', {
+                    rawContent: rawContent.slice(0, 200),
+                });
+                continue;
+            }
+            this.logger.info('Detected legacy SLACK_NOTIFY marker in orchestrator output', {
+                contentLength: payload.message.length,
+            });
+            const fullNotification = this.buildSlackNotification(payload);
+            this.sendToSlackBridge(fullNotification, 'legacy SLACK_NOTIFY');
+        }
+        if (lastMatchEnd > 0) {
+            this.orchestratorOutputBuffer = this.orchestratorOutputBuffer.slice(lastMatchEnd);
+        }
+    }
+    /**
+     * Clear the orchestrator output buffer.
+     * Called when conversation changes or on cleanup.
+     */
+    clearOrchestratorBuffer() {
+        this.orchestratorOutputBuffer = '';
+        this.responseDeduplicator.clear();
+    }
+    /**
+     * Set the active conversation ID for orchestrator chat responses.
+     * Clears the output buffer when conversation changes.
+     *
+     * @param conversationId - The conversation ID to set
+     */
+    setActiveConversationId(conversationId) {
+        // Clear buffer when conversation changes
+        if (conversationId !== this.activeConversationId) {
+            this.clearOrchestratorBuffer();
+        }
+        this.activeConversationId = conversationId;
+    }
+    /**
+     * Get the active conversation ID.
+     *
+     * @returns The active conversation ID or null
+     */
+    getActiveConversationId() {
+        return this.activeConversationId;
+    }
+    /**
+     * Broadcast session status changes.
+     *
+     * @param sessionName - The session name
+     * @param status - The status string
+     */
+    broadcastSessionStatus(sessionName, status) {
+        const message = {
+            type: 'team_status',
+            payload: { sessionName, status },
+            timestamp: new Date().toISOString(),
+        };
+        this.io.to(`terminal_${sessionName}`).emit('session_status', message);
+    }
+    /**
+     * Broadcast general messages to session subscribers.
+     *
+     * @param sessionName - The session name
+     * @param type - Message type
+     * @param payload - Message payload
+     */
+    broadcastMessage(sessionName, type, payload) {
+        const message = {
+            type: type,
+            payload,
+            timestamp: new Date().toISOString(),
+        };
+        this.io.to(`terminal_${sessionName}`).emit(type, message);
+    }
+    /**
+     * Send current terminal state to a new subscriber.
+     *
+     * @param sessionName - The session name
+     * @param socket - The client socket
+     */
+    sendCurrentTerminalState(sessionName, socket) {
+        try {
+            this.logger.debug('Sending current terminal state', {
+                sessionName,
+                socketId: socket.id,
+            });
+            const backend = getSessionBackendSync();
+            if (!backend) {
+                socket.emit('error', {
+                    type: 'terminal_state_error',
+                    payload: { sessionName, error: 'Session backend not initialized' },
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            if (!backend.sessionExists(sessionName)) {
+                this.logger.debug('Session does not exist', { sessionName });
+                socket.emit('session_not_found', {
+                    type: 'session_not_found',
+                    payload: { sessionName },
+                    timestamp: new Date().toISOString(),
+                });
+                return;
+            }
+            // Get raw output history with ANSI codes preserved for color rendering
+            const output = backend.getRawHistory(sessionName);
+            const terminalState = {
+                sessionName,
+                content: output,
+                timestamp: new Date().toISOString(),
+                type: 'stdout',
+            };
+            this.logger.debug('Emitting initial terminal state', {
+                sessionName,
+                contentLength: output.length,
+            });
+            // Send initial terminal state
+            socket.emit('initial_terminal_state', {
+                type: 'initial_terminal_state',
+                payload: terminalState,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            this.logger.error('Error getting terminal state', {
+                sessionName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            socket.emit('error', {
+                type: 'terminal_state_error',
+                payload: {
+                    sessionName,
+                    error: error instanceof Error ? error.message : 'Failed to get terminal state',
+                },
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    /**
+     * Get statistics about connected clients.
+     *
+     * @returns Connection statistics
+     */
+    getConnectionStats() {
+        const sessionSubscriptions = {};
+        for (const [sessionName, clients] of this.connectedClients.entries()) {
+            sessionSubscriptions[sessionName] = clients.size;
+        }
+        return {
+            totalClients: this.io.sockets.sockets.size,
+            sessionSubscriptions,
+            totalSessions: this.connectedClients.size,
+            activeStreams: this.sessionSubscriptions.size,
+        };
+    }
+    /**
+     * Force disconnect all clients from a session.
+     *
+     * @param sessionName - The session name
+     */
+    disconnectSessionClients(sessionName) {
+        this.io.to(`terminal_${sessionName}`).disconnectSockets();
+        this.cleanupSessionSubscription(sessionName);
+        this.logger.info('Disconnected all clients from session', { sessionName });
+    }
+    /**
+     * Broadcast system-wide notifications.
+     *
+     * @param message - Notification message
+     * @param type - Notification type
+     */
+    broadcastSystemNotification(message, type = 'info') {
+        this.io.emit('system_notification', {
+            type: 'system_notification',
+            payload: { message, notificationType: type },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Broadcast orchestrator status changes.
+     *
+     * @param orchestratorData - Orchestrator data
+     */
+    broadcastOrchestratorStatus(orchestratorData) {
+        this.io.emit('orchestrator_status_changed', {
+            type: 'orchestrator_status_changed',
+            payload: orchestratorData,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Broadcast team member status changes.
+     *
+     * @param memberData - Team member data
+     */
+    broadcastTeamMemberStatus(memberData) {
+        this.io.emit('team_member_status_changed', {
+            type: 'team_member_status_changed',
+            payload: memberData,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Broadcast a system resource alert to all connected clients.
+     *
+     * @param alertData - Alert details including key, message, severity, and timestamp
+     */
+    broadcastSystemResourceAlert(alertData) {
+        this.io.emit('system_resource_alert', {
+            type: 'system_resource_alert',
+            payload: alertData,
+            timestamp: alertData.timestamp,
+        });
+    }
+    /**
+     * Broadcast comprehensive team activity updates.
+     *
+     * @param activityData - Activity data
+     */
+    broadcastTeamActivity(activityData) {
+        this.io.emit('team_activity_updated', {
+            type: 'team_activity_updated',
+            payload: activityData,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Destroy the gateway and clean up all subscriptions.
+     */
+    destroy() {
+        // Unsubscribe from all PTY sessions
+        for (const unsubscribe of this.sessionSubscriptions.values()) {
+            unsubscribe();
+        }
+        this.sessionSubscriptions.clear();
+        this.connectedClients.clear();
+        this.persistentMonitoringSessions.clear();
+        this.logger.info('TerminalGateway destroyed');
+    }
+}
+// =============================================================================
+// Singleton Instance
+// =============================================================================
+let terminalGatewayInstance = null;
+/**
+ * Set the terminal gateway singleton instance.
+ * Called during server initialization.
+ *
+ * @param gateway - The TerminalGateway instance
+ */
+export function setTerminalGateway(gateway) {
+    terminalGatewayInstance = gateway;
+}
+/**
+ * Get the terminal gateway singleton instance.
+ *
+ * @returns The TerminalGateway instance or null if not initialized
+ */
+export function getTerminalGateway() {
+    return terminalGatewayInstance;
+}
+/**
+ * Reset the terminal gateway singleton instance (for testing).
+ */
+export function resetTerminalGateway() {
+    terminalGatewayInstance = null;
+}
+//# sourceMappingURL=terminal.gateway.js.map