crewly 1.3.31 → 1.4.0

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

@@ -11,13 +11,6 @@
  */
 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, NOTIFY_CONSTANTS, SLACK_NOTIFY_CONSTANTS, TERMINAL_GATEWAY_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 { extractConversationId, extractMarkerBlocks, extractChatResponseBlocks } from '../utils/terminal-string-ops.js';
-import { parseNotifyContent } from '../types/chat.types.js';
 import { InProcessLogBuffer } from '../services/agent/crewly-agent/in-process-log-buffer.js';
 /**
  * Terminal Gateway class for WebSocket-based terminal streaming.
@@ -39,26 +32,6 @@ export class TerminalGateway {
     persistentMonitoringSessions = new Set();
     /** Current active chat conversation ID for orchestrator responses */
     activeConversationId = null;
-    /** Per-session buffers for [NOTIFY] / legacy marker detection */
-    sessionOutputBuffers = new Map();
-    /** Maximum buffer size to prevent memory issues (100KB) */
-    MAX_BUFFER_SIZE = TERMINAL_GATEWAY_CONSTANTS.MAX_BUFFER_SIZE;
-    /** Deduplicator for recently sent chat responses */
-    responseDeduplicator = new ResponseDeduplicator();
-    /**
-     * Google Chat thread tracking for auto-routing follow-up NOTIFY messages.
-     * Key: space name (e.g. "spaces/jycUeSAAAAE"), value: thread name.
-     * Populated when the queue processor delivers a GCHAT message (via the
-     * google-chat-initializer sourceMetadata). Read by the NOTIFY handler
-     * to send follow-up messages to the correct thread.
-     */
-    gchatThreadMap = new Map();
-    /**
-     * Sessions running Gemini CLI — NOTIFY marker processing is skipped for
-     * these because Gemini TUI garbles markers. They use reply-gchat/reply-slack
-     * skills for response delivery instead.
-     */
-    geminiCliSessions = new Set();
     /**
      * Sessions in read-only mode for security auditing.
      * Terminal output is streamed normally, but all input is blocked.
@@ -86,29 +59,6 @@ export class TerminalGateway {
         this.setupEventHandlers();
         this.setupInProcessLogStreaming();
     }
-    /**
-     * Get the output buffer for a specific session.
-     *
-     * @param sessionName - The session name
-     * @returns The current buffer content
-     */
-    getSessionBuffer(sessionName) {
-        return this.sessionOutputBuffers.get(sessionName) || '';
-    }
-    /**
-     * Set the output buffer for a specific session.
-     *
-     * @param sessionName - The session name
-     * @param value - The new buffer content
-     */
-    setSessionBuffer(sessionName, value) {
-        if (value.length === 0) {
-            this.sessionOutputBuffers.delete(sessionName);
-        }
-        else {
-            this.sessionOutputBuffers.set(sessionName, value);
-        }
-    }
     /**
      * Set up WebSocket event handlers.
      */
@@ -360,9 +310,6 @@ export class TerminalGateway {
             unsubscribe();
             this.sessionSubscriptions.delete(sessionName);
         }
-        // Clear the output buffer and response hash cache for fresh monitoring
-        this.setSessionBuffer(sessionName, '');
-        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);
@@ -551,343 +498,6 @@ export class TerminalGateway {
             timestamp: new Date().toISOString(),
         };
         this.io.to(`terminal_${sessionName}`).emit('terminal_output', message);
-        // Process terminal output for [NOTIFY] markers and chat responses.
-        // Skip Gemini CLI sessions — their TUI garbles NOTIFY markers, producing
-        // false matches with raw artifacts. Gemini CLI agents use reply-gchat and
-        // reply-slack skills for response delivery instead of NOTIFY markers.
-        if (!this.geminiCliSessions.has(sessionName)) {
-            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 extractedConvId = extractConversationId(cleanContent);
-        if (extractedConvId) {
-            this.logger.debug('Extracted conversation ID from output', { conversationId: extractedConvId });
-            this.activeConversationId = extractedConvId;
-        }
-        // Always buffer content per session — notifications don't require a conversation ID
-        const currentBuffer = this.getSessionBuffer(sessionName) + cleanContent;
-        // Prevent buffer from growing too large
-        if (currentBuffer.length > this.MAX_BUFFER_SIZE) {
-            this.setSessionBuffer(sessionName, currentBuffer.slice(-this.MAX_BUFFER_SIZE / 2));
-        }
-        else {
-            this.setSessionBuffer(sessionName, currentBuffer);
-        }
-        // 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(sessionName);
-        this.trimBufferIfNoOpenMarkers(sessionName);
-    }
-    /**
-     * 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 (via skill)
-     * - Both → both (common case for Slack conversation replies)
-     * - No conversationId + activeConversationId exists → fallback to chat
-     * - `type` alone (no conversationId) → dropped (system event, not a conversation reply)
-     *
-     * @param sessionName - The orchestrator session name
-     */
-    /**
-     * Process unified [NOTIFY]...[/NOTIFY] markers from the orchestrator output buffer.
-     *
-     * Filters out false positives from Claude Code tool output display.
-     * When Claude Code reads files (e.g., prompt.md) or runs bash commands,
-     * the displayed output may contain [NOTIFY] example blocks. These are
-     * detected by checking for the ⏺ tool indicator in the text preceding
-     * each match — real NOTIFY blocks are direct AI output (no tool indicator).
-     *
-     * @param sessionName - The orchestrator session name
-     */
-    processNotifyMarkers(sessionName) {
-        const buffer = this.getSessionBuffer(sessionName);
-        if (!buffer.includes(NOTIFY_CONSTANTS.OPEN_TAG)) {
-            return;
-        }
-        const blocks = extractMarkerBlocks(buffer, NOTIFY_CONSTANTS.OPEN_TAG, NOTIFY_CONSTANTS.CLOSE_TAG);
-        let lastMatchEnd = 0;
-        let inToolOutput = false;
-        for (const block of blocks) {
-            // Check if this NOTIFY block is inside Claude Code tool output.
-            // Tool output is preceded by ⏺ (U+23FA). Look at the text between
-            // the previous match end and this match start for state transitions:
-            // - ⏺ with no following ❯ → entering/still in tool output
-            // - ❯ after ⏺ → tool output ended, back to direct AI output
-            const gapText = buffer.slice(lastMatchEnd, block.startIndex);
-            if (gapText.includes('⏺')) {
-                inToolOutput = true;
-            }
-            if (gapText.includes('❯')) {
-                inToolOutput = false;
-            }
-            if (inToolOutput) {
-                this.logger.debug('Skipping NOTIFY inside tool output (false positive)', {
-                    matchStart: block.startIndex,
-                    gapSnippet: gapText.slice(-80),
-                });
-                lastMatchEnd = block.endIndex;
-                continue;
-            }
-            const rawContent = block.content;
-            lastMatchEnd = block.endIndex;
-            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.setSessionBuffer(sessionName, buffer.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) {
-        // Fallback to activeConversationId unless payload.type is set without
-        // a conversationId — those are system event notifications (e.g. status
-        // updates) that should NOT land in a chat conversation.
-        // channelId / threadTs are Slack routing hints and do NOT prevent
-        // the message from also appearing in the chat UI.
-        const canFallbackToActiveConversation = !payload.conversationId
-            && !payload.type;
-        const conversationId = payload.conversationId
-            || (canFallbackToActiveConversation ? this.activeConversationId : null);
-        // Build metadata dict with NOTIFY fields for the chat message.
-        // NOTE: Do NOT set slackDeliveryStatus here. Slack delivery is handled
-        // exclusively by the reply-slack skill. Setting 'pending' here caused
-        // the NotifyReconciliationService to trigger redundant retry storms
-        // for messages that were already delivered by the skill (#retry-storm fix).
-        const metadata = {};
-        if (payload.channelId) {
-            metadata.slackChannelId = payload.channelId;
-            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 service — this emits the ChatMessage event that
-        // QueueProcessor.waitForResponse() listens for to resolve responses.
-        // Google Chat replies ultimately go through the googleChatResolve callback
-        // (queue processor → response router), but the ChatMessage emission is
-        // still needed for waitForResponse to detect the response.
-        // The responseDeduplicator prevents duplicate messages from PTY re-renders.
-        const isGoogleChatConversation = conversationId?.startsWith('spaces/') ?? false;
-        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,
-                    isGoogleChat: isGoogleChatConversation,
-                });
-                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,
-                });
-            }
-        }
-        if (!conversationId && payload.type) {
-            this.logger.debug('Dropping non-conversation NOTIFY payload to avoid cross-thread event leakage', {
-                type: payload.type,
-                hasChannelId: Boolean(payload.channelId),
-            });
-        }
-        // 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(),
-                });
-            }
-        }
-        // Google Chat: no auto-routing here. Initial replies go through the
-        // googleChatResolve callback (queue processor → waitForResponse path).
-        // Follow-up messages are sent by the agent via the reply-gchat skill.
-        // This avoids TUI redraw duplicates and NOTIFY parsing issues.
-    }
-    /**
-     * Register a Google Chat thread mapping so follow-up NOTIFY messages
-     * for the given space are routed to the correct thread.
-     *
-     * Called by the google-chat-initializer when a new GCHAT message is enqueued.
-     *
-     * @param space - Google Chat space name (e.g. "spaces/jycUeSAAAAE")
-     * @param threadName - Thread name for replies (e.g. "spaces/jycUeSAAAAE/threads/BBB")
-     */
-    registerGchatThread(space, threadName) {
-        this.gchatThreadMap.set(space, threadName);
-    }
-    /**
-     * Pre-load Gemini CLI session names from StorageService.
-     * Call during startup (after StorageService is initialized) to ensure
-     * NOTIFY marker processing is skipped for existing Gemini CLI sessions
-     * that are already streaming before registerGeminiCliSession is called.
-     */
-    async loadGeminiCliSessions() {
-        try {
-            const { StorageService } = await import('../services/core/storage.service.js');
-            const storageService = StorageService.getInstance();
-            const teams = await storageService.getTeams();
-            for (const team of teams) {
-                for (const member of team.members) {
-                    if (member.runtimeType === 'gemini-cli' && member.sessionName) {
-                        this.geminiCliSessions.add(member.sessionName);
-                    }
-                }
-            }
-            // Check orchestrator runtimeType from storage
-            const orcStatus = await storageService.getOrchestratorStatus();
-            if (orcStatus?.runtimeType === 'gemini-cli') {
-                this.geminiCliSessions.add(ORCHESTRATOR_SESSION_NAME);
-            }
-            if (this.geminiCliSessions.size > 0) {
-                this.logger.info('Pre-loaded Gemini CLI sessions for NOTIFY skip', {
-                    sessions: [...this.geminiCliSessions],
-                });
-            }
-        }
-        catch (error) {
-            this.logger.warn('Failed to pre-load Gemini CLI sessions (non-fatal)', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    /**
-     * Register a session as running Gemini CLI.
-     * NOTIFY marker processing is skipped for these sessions because the
-     * Gemini TUI garbles marker output. Gemini CLI agents use reply-gchat
-     * and reply-slack skills for response delivery instead.
-     *
-     * @param sessionName - The Gemini CLI session name
-     */
-    registerGeminiCliSession(sessionName) {
-        this.geminiCliSessions.add(sessionName);
-    }
-    /**
-     * Unregister a Gemini CLI session (e.g. on session destroy).
-     *
-     * @param sessionName - The session name to unregister
-     */
-    unregisterGeminiCliSession(sessionName) {
-        this.geminiCliSessions.delete(sessionName);
     }
     /**
      * Enable read-only mode for a session. Output streaming continues but
@@ -917,137 +527,12 @@ export class TerminalGateway {
     isReadOnly(sessionName) {
         return this.readOnlySessions.has(sessionName);
     }
-    /**
-     * Trim the orchestrator output buffer if there are no pending open markers.
-     * Prevents unbounded growth when output doesn't contain any markers.
-     */
-    trimBufferIfNoOpenMarkers(sessionName) {
-        const buffer = this.getSessionBuffer(sessionName);
-        const hasPendingMarker = buffer.includes(NOTIFY_CONSTANTS.OPEN_TAG) ||
-            buffer.includes('[CHAT_RESPONSE') ||
-            buffer.includes(SLACK_NOTIFY_CONSTANTS.OPEN_TAG);
-        if (!hasPendingMarker) {
-            // Keep a small trailing buffer in case the tag is split across chunks
-            const lastNewline = buffer.lastIndexOf('\n');
-            if (lastNewline > TERMINAL_GATEWAY_CONSTANTS.BUFFER_TRIM_THRESHOLD) {
-                this.setSessionBuffer(sessionName, buffer.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;
-        }
-        const buffer = this.getSessionBuffer(sessionName);
-        if (!buffer.includes('[CHAT_RESPONSE')) {
-            return;
-        }
-        this.logger.debug('Processing legacy [CHAT_RESPONSE] markers (deprecated — use [NOTIFY])');
-        const chatGateway = getChatGateway();
-        if (!chatGateway) {
-            return;
-        }
-        const blocks = extractChatResponseBlocks(buffer);
-        let lastMatchEnd = 0;
-        for (const block of blocks) {
-            const embeddedConversationId = block.conversationId;
-            const responseContent = block.content;
-            lastMatchEnd = block.endIndex;
-            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.setSessionBuffer(sessionName, buffer.slice(lastMatchEnd));
-        }
-    }
-    /**
-     * Process legacy [SLACK_NOTIFY]...[/SLACK_NOTIFY] markers from the buffer.
-     * @deprecated Use [NOTIFY] markers instead. Kept for backward compatibility.
-     *
-     * @param sessionName - The session name
-     */
-    processLegacySlackNotifications(sessionName) {
-        const buffer = this.getSessionBuffer(sessionName);
-        if (!buffer.includes(SLACK_NOTIFY_CONSTANTS.OPEN_TAG)) {
-            return;
-        }
-        this.logger.debug('Processing legacy [SLACK_NOTIFY] markers (deprecated — use [NOTIFY])');
-        const blocks = extractMarkerBlocks(buffer, SLACK_NOTIFY_CONSTANTS.OPEN_TAG, SLACK_NOTIFY_CONSTANTS.CLOSE_TAG);
-        let lastMatchEnd = 0;
-        for (const block of blocks) {
-            const rawContent = block.content;
-            lastMatchEnd = block.endIndex;
-            // 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.setSessionBuffer(sessionName, buffer.slice(lastMatchEnd));
-        }
-    }
-    /**
-     * Clear output buffers for all sessions.
-     * Called when conversation changes or on cleanup.
-     */
-    clearOrchestratorBuffer() {
-        this.sessionOutputBuffers.clear();
-        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;
     }
     /**