factory-factory 0.2.8 → 0.3.0

package/dist/src/backend/domains/session/chat/chat-event-forwarder.service.js

@@ -1,23 +1,10 @@
-import { EventEmitter } from 'node:events';
-import { existsSync, readFileSync } from 'node:fs';
-import { WS_READY_STATE } from '../../../../backend/constants/index.js';
-import { sessionFileLogger } from '../../../../backend/domains/session/logging/session-file-logger.service.js';
+import { WS_READY_STATE } from '../../../../backend/constants/websocket.js';
 import { sessionDomainService } from '../../../../backend/domains/session/session-domain.service.js';
-import { interceptorRegistry } from '../../../../backend/interceptors/index.js';
-import { AskUserQuestionInputSchema, ExitPlanModeInputSchema, extractInputValue, isString, safeParseToolInput, } from '../../../../backend/schemas/tool-inputs.schema.js';
-import { configService } from '../../../../backend/services/config.service.js';
 import { createLogger } from '../../../../backend/services/logger.service.js';
-import { slashCommandCacheService } from '../../../../backend/services/slash-command-cache.service.js';
-import { hasToolResultContent } from '../../../../shared/claude/index.js';
-import { isInteractiveResponseTool, } from '../../../../shared/pending-request-types.js';
 import { chatConnectionService } from './chat-connection.service.js';
 const logger = createLogger('chat-event-forwarder');
-const DEBUG_CHAT_WS = configService.getDebugConfig().chatWebSocket;
 class ChatEventForwarderService {
-    clientEventSetup = new Map();
-    registeredListeners = new Map();
     workspaceNotificationsSetup = false;
-    lastCompactBoundaryAt = new Map();
     workspaceBridge = null;
     configure(bridges) {
         this.workspaceBridge = bridges.workspace;
@@ -28,24 +15,8 @@ class ChatEventForwarderService {
         }
         return this.workspaceBridge;
     }
-    forwardClaudeMessage(dbSessionId, message) {
-        const order = sessionDomainService.appendClaudeEvent(dbSessionId, message);
-        const wsMsg = order === undefined
-            ? { type: 'claude_message', data: message }
-            : { type: 'claude_message', data: message, order };
-        sessionDomainService.emitDelta(dbSessionId, wsMsg);
-    }
-    removeForwardingListeners(dbSessionId, client) {
-        const listeners = this.registeredListeners.get(dbSessionId);
-        if (listeners) {
-            for (const { event, handler } of listeners) {
-                client.off(event, handler);
-            }
-            this.registeredListeners.delete(dbSessionId);
-        }
-    }
-    isSetup(dbSessionId) {
-        return this.clientEventSetup.has(dbSessionId);
+    isSetup(_dbSessionId) {
+        return false;
     }
     getPendingRequest(dbSessionId) {
         return sessionDomainService.getPendingInteractiveRequest(dbSessionId) ?? undefined;
@@ -83,590 +54,9 @@ class ChatEventForwarderService {
             }
         });
     }
-    setupClientEvents(dbSessionId, client, context, onDispatchNextMessage) {
-        const existingClient = this.clientEventSetup.get(dbSessionId);
-        if (existingClient === client) {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Event forwarding already set up for same client, skipping', {
-                    dbSessionId,
-                });
-            }
-            return;
-        }
-        if (existingClient) {
-            logger.info('[Chat WS] Replacing event forwarding with new client', { dbSessionId });
-            this.removeForwardingListeners(dbSessionId, existingClient);
-            sessionDomainService.clearPendingInteractiveRequest(dbSessionId);
-        }
-        this.clientEventSetup.set(dbSessionId, client);
-        if (DEBUG_CHAT_WS) {
-            logger.info('[Chat WS] Setting up event forwarding for session', { dbSessionId });
-        }
-        const emitterOn = EventEmitter.prototype.on.bind(client);
-        const listeners = [];
-        const on = (event, handler) => {
-            emitterOn(event, handler);
-            listeners.push({ event, handler });
-        };
-        this.registeredListeners.set(dbSessionId, listeners);
-        const initResponse = client.getInitializeResponse();
-        if (initResponse?.commands && initResponse.commands.length > 0) {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Forwarding slash commands to frontend', {
-                    dbSessionId,
-                    commandCount: initResponse.commands.length,
-                });
-            }
-            const slashCommandsMsg = {
-                type: 'slash_commands',
-                slashCommands: initResponse.commands,
-            };
-            sessionDomainService.emitDelta(dbSessionId, slashCommandsMsg);
-            void slashCommandCacheService.setCachedCommands(initResponse.commands);
-        }
-        const pendingToolNames = new Map();
-        const pendingToolInputs = new Map();
-        on('tool_use', (toolUse) => {
-            pendingToolNames.set(toolUse.id, toolUse.name);
-            pendingToolInputs.set(toolUse.id, toolUse.input);
-            interceptorRegistry.notifyToolStart({ toolUseId: toolUse.id, toolName: toolUse.name, input: toolUse.input }, {
-                sessionId: dbSessionId,
-                workspaceId: context.workspaceId,
-                workingDir: context.workingDir,
-                timestamp: new Date(),
-            });
-        });
-        on('session_id', (claudeSessionId) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received session_id from Claude CLI', {
-                    dbSessionId,
-                    claudeSessionId,
-                });
-            }
-            this.workspace.markSessionRunning(context.workspaceId, dbSessionId);
-            this.syncRuntimeFromClient(dbSessionId, client);
-        });
-        on('idle', () => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Claude became idle, checking queue', { dbSessionId });
-            }
-            void onDispatchNextMessage()
-                .catch((error) => {
-                logger.error('[Chat WS] Error dispatching queued message on idle', {
-                    dbSessionId,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            })
-                .finally(() => {
-                if (!client.isWorking()) {
-                    this.workspace.markSessionIdle(context.workspaceId, dbSessionId);
-                }
-                this.syncRuntimeFromClient(dbSessionId, client);
-            });
-        });
-        on('stream', (event) => {
-            const streamEvent = event;
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received stream event from client', {
-                    dbSessionId,
-                    eventType: streamEvent.type,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'stream', data: event });
-            this.forwardClaudeMessage(dbSessionId, event);
-        });
-        const registerLoggedDeltaEvent = (eventName, options = {}) => {
-            on(eventName, (event) => {
-                if (DEBUG_CHAT_WS) {
-                    logger.info(options.debugMessage ?? `[Chat WS] Received ${eventName} event`, {
-                        dbSessionId,
-                        ...(options.debugData?.(event) ?? {}),
-                    });
-                }
-                sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                    eventType: eventName,
-                    data: event,
-                });
-                sessionDomainService.emitDelta(dbSessionId, options.mapDelta?.(event) ?? event);
-            });
-        };
-        const mappedDeltaEvents = [
-            {
-                eventName: 'tool_progress',
-                debugMessage: '[Chat WS] Received tool_progress event',
-            },
-            {
-                eventName: 'tool_use_summary',
-                debugMessage: '[Chat WS] Received tool_use_summary event',
-            },
-            {
-                eventName: 'system_init',
-                debugMessage: '[Chat WS] Received system_init event',
-                debugData: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        tools: event.tools?.length ?? 0,
-                        model: event.model,
-                    };
-                },
-                mapDelta: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        type: 'system_init',
-                        data: {
-                            tools: event.tools,
-                            model: event.model,
-                            cwd: event.cwd,
-                            apiKeySource: event.apiKeySource,
-                            slashCommands: event.slash_commands,
-                            plugins: event.plugins,
-                        },
-                    };
-                },
-            },
-            {
-                eventName: 'system_status',
-                debugMessage: '[Chat WS] Received system_status event',
-                debugData: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        status: event.status,
-                        permission_mode: event.permission_mode,
-                    };
-                },
-                mapDelta: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        type: 'status_update',
-                        permissionMode: event.permission_mode,
-                    };
-                },
-            },
-            {
-                eventName: 'hook_started',
-                debugMessage: '[Chat WS] Received hook_started event',
-                debugData: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        hookId: event.hook_id,
-                        hookName: event.hook_name,
-                        hookEvent: event.hook_event,
-                    };
-                },
-                mapDelta: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        type: 'hook_started',
-                        data: {
-                            hookId: event.hook_id,
-                            hookName: event.hook_name,
-                            hookEvent: event.hook_event,
-                        },
-                    };
-                },
-            },
-            {
-                eventName: 'hook_response',
-                debugMessage: '[Chat WS] Received hook_response event',
-                debugData: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        hookId: event.hook_id,
-                        exitCode: event.exit_code,
-                        outcome: event.outcome,
-                    };
-                },
-                mapDelta: (rawEvent) => {
-                    const event = rawEvent;
-                    return {
-                        type: 'hook_response',
-                        data: {
-                            hookId: event.hook_id,
-                            output: event.output,
-                            stdout: event.stdout,
-                            stderr: event.stderr,
-                            exitCode: event.exit_code,
-                            outcome: event.outcome,
-                        },
-                    };
-                },
-            },
-        ];
-        for (const eventConfig of mappedDeltaEvents) {
-            registerLoggedDeltaEvent(eventConfig.eventName, {
-                debugMessage: eventConfig.debugMessage,
-                debugData: eventConfig.debugData,
-                mapDelta: eventConfig.mapDelta,
-            });
-        }
-        on('compact_boundary', (event) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received compact_boundary event', { dbSessionId });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'compact_boundary',
-                data: event,
-            });
-            const now = Date.now();
-            const lastBoundary = this.lastCompactBoundaryAt.get(dbSessionId) ?? 0;
-            if (now - lastBoundary < 1000) {
-                return;
-            }
-            this.lastCompactBoundaryAt.set(dbSessionId, now);
-            const boundaryMsg = { type: 'compact_boundary' };
-            sessionDomainService.emitDelta(dbSessionId, boundaryMsg);
-        });
-        for (const compactEventName of ['compacting_start', 'compacting_end']) {
-            on(compactEventName, () => {
-                if (DEBUG_CHAT_WS) {
-                    logger.info(compactEventName === 'compacting_start'
-                        ? '[Chat WS] Context compaction started'
-                        : '[Chat WS] Context compaction ended', { dbSessionId });
-                }
-                sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: compactEventName });
-                sessionDomainService.emitDelta(dbSessionId, { type: compactEventName });
-            });
-        }
-        on('message', (msg) => {
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'message', data: msg });
-            this.handleMessageEvent(dbSessionId, msg, pendingToolNames, pendingToolInputs, context);
-        });
-        on('result', (result) => {
-            if (DEBUG_CHAT_WS) {
-                const res = result;
-                logger.info('[Chat WS] Received result event from client', { dbSessionId, uuid: res.uuid });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', { eventType: 'result', data: result });
-            this.forwardClaudeMessage(dbSessionId, result);
-            this.workspace.markSessionIdle(context.workspaceId, dbSessionId);
-            this.syncRuntimeFromClient(dbSessionId, client);
-        });
-        on('interactive_request', (request) => {
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Received interactive_request from client', {
-                    dbSessionId,
-                    toolName: request.toolName,
-                    requestId: request.requestId,
-                });
-            }
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'interactive_request',
-                data: request,
-            });
-            this.routeInteractiveRequest(dbSessionId, request, client);
-        });
-        on('exit', () => {
-            this.removeForwardingListeners(dbSessionId, client);
-            this.clientEventSetup.delete(dbSessionId);
-            this.lastCompactBoundaryAt.delete(dbSessionId);
-        });
-        on('permission_cancelled', (requestId) => {
-            sessionFileLogger.log(dbSessionId, 'FROM_CLAUDE_CLI', {
-                eventType: 'permission_cancelled',
-                requestId,
-            });
-            this.clearPendingRequestIfMatches(dbSessionId, requestId);
-            sessionDomainService.emitDelta(dbSessionId, {
-                type: 'permission_cancelled',
-                requestId,
-            });
-        });
-        on('error', (error) => {
-            sessionDomainService.emitDelta(dbSessionId, {
-                type: 'error',
-                message: error.message,
-            });
-        });
-    }
-    routeInteractiveRequest(dbSessionId, request, client) {
-        if (!isInteractiveResponseTool(request.toolName)) {
-            const reason = `Unsupported interactive tool: ${request.toolName}`;
-            logger.warn('[Chat WS] Denying unsupported interactive request', {
-                dbSessionId,
-                requestId: request.requestId,
-                toolName: request.toolName,
-            });
-            try {
-                client.denyInteractiveRequest(request.requestId, reason);
-            }
-            catch (error) {
-                logger.error('[Chat WS] Failed to deny unsupported interactive request', {
-                    dbSessionId,
-                    requestId: request.requestId,
-                    toolName: request.toolName,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            sessionDomainService.emitDelta(dbSessionId, {
-                type: 'error',
-                message: reason,
-            });
-            return;
-        }
-        const planContent = request.toolName === 'ExitPlanMode' ? this.extractPlanContent(request.input) : null;
-        this.routeSupportedInteractiveRequest(dbSessionId, { ...request, toolName: request.toolName }, planContent, client);
-    }
-    routeSupportedInteractiveRequest(dbSessionId, request, planContent, client) {
-        switch (request.toolName) {
-            case 'AskUserQuestion': {
-                const parsed = safeParseToolInput(AskUserQuestionInputSchema, request.input, 'AskUserQuestion', logger);
-                if (!parsed.success || parsed.data.questions.length === 0) {
-                    logger.warn('[Chat WS] Invalid or empty AskUserQuestion input', {
-                        dbSessionId,
-                        requestId: request.requestId,
-                        validationSuccess: parsed.success,
-                    });
-                    try {
-                        client.denyInteractiveRequest(request.requestId, 'Invalid question format - unable to display question');
-                    }
-                    catch (error) {
-                        logger.error('[Chat WS] Failed to deny invalid AskUserQuestion request', {
-                            dbSessionId,
-                            requestId: request.requestId,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                    sessionDomainService.emitDelta(dbSessionId, {
-                        type: 'error',
-                        message: 'Received invalid question format from CLI',
-                    });
-                    return;
-                }
-                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
-                sessionDomainService.emitDelta(dbSessionId, {
-                    type: 'user_question',
-                    requestId: request.requestId,
-                    questions: parsed.data.questions,
-                });
-                return;
-            }
-            case 'ExitPlanMode':
-                this.storePendingInteractiveRequest(dbSessionId, request, planContent);
-                sessionDomainService.emitDelta(dbSessionId, {
-                    type: 'permission_request',
-                    requestId: request.requestId,
-                    toolName: request.toolName,
-                    toolInput: request.input,
-                    planContent,
-                });
-                return;
-            default: {
-                const unreachable = request.toolName;
-                logger.error('[Chat WS] Unhandled interactive response tool', {
-                    dbSessionId,
-                    requestId: request.requestId,
-                    toolName: unreachable,
-                });
-            }
-        }
-    }
-    storePendingInteractiveRequest(dbSessionId, request, planContent) {
-        sessionDomainService.setPendingInteractiveRequest(dbSessionId, {
-            requestId: request.requestId,
-            toolName: request.toolName,
-            toolUseId: request.toolUseId,
-            input: request.input,
-            planContent,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    handleMessageEvent(dbSessionId, msg, pendingToolNames, pendingToolInputs, context) {
-        const msgWithType = msg;
-        if (msgWithType.type === 'assistant') {
-            this.forwardAssistantTextMessage(dbSessionId, msg, msgWithType);
-            return;
-        }
-        if (msgWithType.type !== 'user') {
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'skipped_message',
-                reason: 'not_user_type',
-                type: msgWithType.type,
-            });
-            return;
-        }
-        this.forwardUserMessageWithToolResult(dbSessionId, msg, msgWithType, pendingToolNames, pendingToolInputs, context);
-    }
-    forwardAssistantTextMessage(dbSessionId, msg, msgWithType) {
-        const assistantMsg = msg;
-        const fallbackToolUseEvents = this.buildToolUseFallbackStreamEvents(assistantMsg);
-        for (const toolUseEvent of fallbackToolUseEvents) {
-            this.forwardClaudeMessage(dbSessionId, toolUseEvent);
-        }
-        const content = msgWithType.message?.content;
-        if (!Array.isArray(content)) {
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'skipped_message',
-                reason: 'assistant_no_array_content',
-            });
-            return;
-        }
-        const hasNarrativeText = content.some((item) => item.type === 'text' && typeof item.text === 'string');
-        if (!hasNarrativeText) {
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'skipped_message',
-                reason: 'assistant_no_text_content',
-            });
-            return;
-        }
-        const normalized = this.normalizeAssistantMessageToTextOnly(assistantMsg);
-        if (!normalized) {
-            return;
-        }
-        this.forwardClaudeMessage(dbSessionId, normalized);
-    }
-    buildToolUseFallbackStreamEvents(message) {
-        if (message.type !== 'assistant') {
-            return [];
-        }
-        const content = message.message?.content;
-        if (!Array.isArray(content)) {
-            return [];
-        }
-        const fallbackEvents = [];
-        for (const [index, item] of content.entries()) {
-            if (item.type !== 'tool_use') {
-                continue;
-            }
-            fallbackEvents.push({
-                type: 'stream_event',
-                event: {
-                    type: 'content_block_start',
-                    index,
-                    content_block: item,
-                },
-                timestamp: message.timestamp ?? new Date().toISOString(),
-            });
-        }
-        return fallbackEvents;
-    }
-    normalizeAssistantMessageToTextOnly(message) {
-        if (message.type !== 'assistant') {
-            return null;
-        }
-        const content = message.message?.content;
-        if (!Array.isArray(content)) {
-            return null;
-        }
-        const textBlocks = content.filter((item) => item.type === 'text' && typeof item.text === 'string');
-        if (textBlocks.length === 0) {
-            return null;
-        }
-        return {
-            ...message,
-            message: {
-                role: 'assistant',
-                content: textBlocks,
-            },
-        };
-    }
-    forwardUserMessageWithToolResult(dbSessionId, msg, msgWithType, pendingToolNames, pendingToolInputs, context) {
-        if (msgWithType.uuid) {
-            const uuidMsg = { type: 'user_message_uuid', uuid: msgWithType.uuid };
-            sessionDomainService.emitDelta(dbSessionId, uuidMsg);
-            if (DEBUG_CHAT_WS) {
-                logger.info('[Chat WS] Forwarding user message UUID', {
-                    dbSessionId,
-                    uuid: msgWithType.uuid,
-                });
-            }
-        }
-        const content = msgWithType.message?.content;
-        if (!Array.isArray(content)) {
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'skipped_message',
-                reason: 'no_array_content',
-            });
-            return;
-        }
-        const hasToolResult = hasToolResultContent(content);
-        if (!hasToolResult) {
-            sessionFileLogger.log(dbSessionId, 'INFO', {
-                action: 'skipped_message',
-                reason: 'no_tool_result_content',
-                content_types: content.map((c) => c.type),
-            });
-            return;
-        }
-        this.notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, {
-            sessionId: dbSessionId,
-            workspaceId: context.workspaceId,
-            workingDir: context.workingDir,
-        });
-        if (DEBUG_CHAT_WS) {
-            logger.info('[Chat WS] Forwarding user message with tool_result', { dbSessionId });
-        }
-        sessionFileLogger.log(dbSessionId, 'INFO', {
-            action: 'forwarding_user_message_with_tool_result',
-        });
-        this.forwardClaudeMessage(dbSessionId, msg);
-    }
-    extractPlanContent(input) {
-        const parsed = ExitPlanModeInputSchema.safeParse(input);
-        if (!parsed.success) {
-            logger.warn('[Chat WS] ExitPlanMode input validation failed', {
-                errors: parsed.error.issues.map((i) => ({ path: i.path, message: i.message })),
-                inputKeys: Object.keys(input),
-            });
-        }
-        const inlinePlan = extractInputValue(input, 'plan', isString, 'ExitPlanMode', logger);
-        if (inlinePlan) {
-            return inlinePlan;
-        }
-        const planFile = extractInputValue(input, 'planFile', isString, 'ExitPlanMode', logger);
-        if (planFile) {
-            return this.readPlanFileContent(planFile);
-        }
-        return null;
-    }
-    readPlanFileContent(planFile) {
-        if (!existsSync(planFile)) {
-            logger.debug('[Chat WS] Plan file does not exist', { planFile });
-            return null;
-        }
-        try {
-            return readFileSync(planFile, 'utf-8');
-        }
-        catch (error) {
-            logger.error('[Chat WS] Failed to read plan file - user will see empty plan content', {
-                planFile,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return null;
-        }
-    }
     getAllPendingRequests() {
         return sessionDomainService.getAllPendingRequests();
     }
-    notifyToolResultInterceptors(content, pendingToolNames, pendingToolInputs, interceptorContext) {
-        for (const item of content) {
-            const typedItem = item;
-            if (typedItem.type !== 'tool_result' || !typedItem.tool_use_id) {
-                continue;
-            }
-            const toolName = pendingToolNames.get(typedItem.tool_use_id) ?? 'unknown';
-            const toolInput = pendingToolInputs.get(typedItem.tool_use_id) ?? {};
-            interceptorRegistry.notifyToolComplete({
-                toolUseId: typedItem.tool_use_id,
-                toolName,
-                input: toolInput,
-                output: {
-                    content: typeof typedItem.content === 'string'
-                        ? typedItem.content
-                        : JSON.stringify(typedItem.content),
-                    isError: typedItem.is_error ?? false,
-                },
-            }, { ...interceptorContext, timestamp: new Date() });
-            pendingToolNames.delete(typedItem.tool_use_id);
-            pendingToolInputs.delete(typedItem.tool_use_id);
-        }
-    }
-    syncRuntimeFromClient(dbSessionId, client) {
-        if (client.isWorking()) {
-            sessionDomainService.markRunning(dbSessionId);
-            return;
-        }
-        sessionDomainService.markIdle(dbSessionId, client.isRunning() ? 'alive' : 'stopped');
-    }
 }
 export const chatEventForwarderService = new ChatEventForwarderService();
 //# sourceMappingURL=chat-event-forwarder.service.js.map