dynamic-interaction
Version:
Dynamic interaction 动态交互mcp，用于cursor、windsurf、trae 等 AI 智能编辑器 Agent 运行时交互使用
119 lines (118 loc) • 5.25 kB
JavaScript
;
/**
* 消息处理器
* 统一的消息处理入口，整合路由和会话处理
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.messageProcessor = exports.MessageProcessor = void 0;
const logger_1 = require("../../logger");
const router_1 = require("./router");
const manager_1 = require("../session/manager");
const queue_1 = require("../session/queue");
const transport_1 = require("../websocket/transport");
const connection_1 = require("../websocket/connection");
const store_1 = require("../notifications/store");
const session_1 = require("../../types/session");
const errors_1 = require("../utils/errors");
const websocket_1 = require("../../types/websocket");
class MessageProcessor {
static instance;
constructor() {
this.registerDefaultHandlers();
}
static getInstance() {
if (!MessageProcessor.instance) {
MessageProcessor.instance = new MessageProcessor();
}
return MessageProcessor.instance;
}
async process(ws, message) {
if (!(0, websocket_1.isValidMessage)(message)) {
logger_1.logger.warn('收到无效的WebSocket消息');
transport_1.transport.sendError(ws, '无效的消息格式', errors_1.ErrorCodes.INVALID_MESSAGE_FORMAT);
return;
}
logger_1.logger.debug(`处理客户端消息，类型: ${message.type}`);
await router_1.messageRouter.route(ws, { type: message.type, data: message.data || {} });
}
async processSessionRequest(ws, request) {
logger_1.logger.debug(`处理会话请求，ID: ${request.id}，模式: ${request.mode}`);
try {
switch (request.mode) {
case session_1.SessionMode.NOTIFICATION:
await this.processNotificationRequest(ws, request);
break;
case session_1.SessionMode.INTERACTIVE:
await this.processInteractiveRequest(ws, request);
break;
default:
throw new errors_1.ValidationError(`未知的会话模式: ${request.mode}`);
}
}
catch (error) {
logger_1.logger.error(`处理会话请求失败，ID: ${request.id}:`, error);
if (error instanceof errors_1.ValidationError) {
transport_1.transport.sendError(ws, error.message, error.code, request.id);
request.reject(error);
}
else {
transport_1.transport.sendError(ws, '会话处理失败', errors_1.ErrorCodes.SESSION_CREATION_ERROR, request.id);
queue_1.sessionQueue.requeue(request.id, error);
}
}
}
async processNotificationRequest(ws, request) {
logger_1.logger.info(`处理通知请求，ID: ${request.id}`);
// 发送通知消息
transport_1.transport.sendNotification(ws, request.id, request.summary, request.projectDirectory);
// 存储通知
store_1.notificationStore.addNotification({
id: request.id,
summary: request.summary,
projectDirectory: request.projectDirectory,
createdAt: request.createdAt,
acknowledged: false
});
// 通知模式不需要等待用户响应，立即确认
queue_1.sessionQueue.acknowledge(request.id);
request.resolve({ text: '通知已成功发送' });
logger_1.logger.info(`通知消息已发送，ID: ${request.id}`);
}
async processInteractiveRequest(ws, request) {
logger_1.logger.info(`处理交互请求，ID: ${request.id}`);
// 创建会话
const session = manager_1.sessionManager.createSession(ws, request);
// 发送会话请求消息
transport_1.transport.sendSessionRequest(ws, request.id, request.summary, request.projectDirectory, session.startTime, session.timeout);
logger_1.logger.info(`交互会话已创建，ID: ${request.id}`);
}
registerDefaultHandlers() {
// 自动导入并注册处理器
try {
require('./handlers');
logger_1.logger.info('默认消息处理器已注册');
}
catch (error) {
logger_1.logger.error('注册默认消息处理器失败:', error);
}
}
checkQueueAndProcess() {
if (queue_1.sessionQueue.isWaitingQueueEmpty()) {
const { lifecycleManager } = require('../core/lifecycle');
lifecycleManager.checkAndStopIfIdle();
return;
}
const availableWs = connection_1.webSocketManager.getAvailableConnection();
if (availableWs) {
const sessionRequest = queue_1.sessionQueue.leaseNext();
if (sessionRequest) {
logger_1.logger.info(`为会话 ${sessionRequest.id} 分配了可用连接，模式: ${sessionRequest.mode}`);
this.processSessionRequest(availableWs, sessionRequest).catch(error => {
logger_1.logger.error('处理会话请求时出错:', error);
});
}
}
}
}
exports.MessageProcessor = MessageProcessor;
exports.messageProcessor = MessageProcessor.getInstance();