@nestjs-mcp/server
Version:
Modular library for building scalable MCP servers with NestJS, providing decorators and integration patterns as a wrapper for the official MCP TypeScript SDK.
171 lines • 7.4 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SseService = void 0;
const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
const common_1 = require("@nestjs/common");
const mcp_constants_1 = require("../../mcp.constants");
const logger_service_1 = require("../../services/logger.service");
const registry_service_1 = require("../../services/registry.service");
const session_manager_1 = require("../../services/session.manager");
let SseService = class SseService {
options;
sessionOptions;
transportOptions;
registry;
logger;
sessionManager;
sessionTimeoutMs;
maxConcurrentSessions;
cleanupIntervalMs;
enabled;
cleanupTimer;
constructor(options, sessionOptions, transportOptions, registry, logger, sessionManager) {
this.options = options;
this.sessionOptions = sessionOptions;
this.transportOptions = transportOptions;
this.registry = registry;
this.logger = logger;
this.sessionManager = sessionManager;
this.enabled = transportOptions?.sse?.enabled !== false;
this.sessionTimeoutMs = sessionOptions.sessionTimeoutMs ?? 1800000;
this.maxConcurrentSessions = sessionOptions.maxConcurrentSessions ?? 1000;
this.cleanupIntervalMs = sessionOptions.cleanupIntervalMs ?? 300000;
}
onModuleInit() {
if (!this.enabled) {
this.logger.log('SSE transport disabled', 'MCP_SERVER');
return;
}
this.logger.log('MCP initialization completed', 'MCP_SERVER');
this.startCleanupJob();
}
onModuleDestroy() {
this.stopCleanupJob();
}
startCleanupJob() {
this.cleanupTimer = setInterval(() => {
this.cleanupInactiveSessions();
}, this.cleanupIntervalMs);
}
stopCleanupJob() {
if (this.cleanupTimer) {
clearInterval(this.cleanupTimer);
}
}
cleanupInactiveSessions() {
const inactiveSessions = this.sessionManager.getInactiveSessions(this.sessionTimeoutMs);
if (inactiveSessions.length > 0) {
this.logger.debug(`Cleaning up ${inactiveSessions.length} inactive sessions`, 'SSE');
for (const sessionId of inactiveSessions) {
const session = this.sessionManager.getSession(sessionId);
if (session) {
try {
void session.transport.close();
}
catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
this.logger.error(`Error closing transport for session ${sessionId}`, errorMessage, 'SSE');
}
this.sessionManager.deleteSession(sessionId);
}
}
}
}
createServer() {
const server = new mcp_js_1.McpServer(this.options.serverInfo, this.options.options);
this.registry.registerAll(server);
return server;
}
async handleSse(req, res) {
if (!this.enabled) {
res.status(404).send('SSE transport is disabled');
return;
}
if (this.sessionManager.getActiveSessionCount() >= this.maxConcurrentSessions) {
this.logger.warn(`Maximum concurrent sessions reached: ${this.maxConcurrentSessions}`, 'SSE');
res
.status(503)
.send('Service temporarily unavailable: Maximum concurrent sessions reached');
return;
}
const transport = new sse_js_1.SSEServerTransport('/messages', res);
this.sessionManager.setSession(transport.sessionId, {
transport,
request: req,
});
this.logger.debug(`Starting SSE for sessionId: ${transport.sessionId}`, 'SSE');
res.on('close', () => {
this.logger.debug(`SSE connection closed for session: ${transport.sessionId}`, 'SSE');
this.sessionManager.deleteSession(transport.sessionId);
});
try {
const server = this.createServer();
await server.connect(transport);
}
catch (error) {
this.logger.error('Failed to create or connect server', error, 'SSE');
this.sessionManager.deleteSession(transport.sessionId);
res.status(500).send('Internal server error');
}
}
async handleMessage(req, res) {
if (!this.enabled) {
res.status(404).send('SSE transport is disabled');
return;
}
const sessionId = req.query.sessionId;
const session = this.sessionManager.getSession(sessionId);
if (!session) {
res.status(400).send('Invalid or missing sessionId');
return;
}
this.logger.debug(`Receiving SSE message for sessionId: ${sessionId}`, 'api');
this.logger.debug(`SSE message: ${JSON.stringify(req.body)}`, 'MCP_SERVER');
const transport = session.transport;
if (!(transport instanceof sse_js_1.SSEServerTransport)) {
res.status(400).send('Invalid transport');
return;
}
try {
if (transport) {
await transport.handlePostMessage(req, res, req.body);
}
else {
res.status(400).send('No transport found for sessionId');
}
}
catch (error) {
const errorMessage = error instanceof Error ? error.message : 'Unknown error';
this.logger.error('Error al manejar mensaje SSE', errorMessage, 'MCP_SERVER');
res.status(500).send({
statusCode: 500,
error: 'Internal Server Error',
message: errorMessage,
});
}
}
};
exports.SseService = SseService;
exports.SseService = SseService = __decorate([
(0, common_1.Injectable)(),
__param(0, (0, common_1.Inject)(mcp_constants_1.MCP_SERVER_OPTIONS)),
__param(1, (0, common_1.Inject)(mcp_constants_1.MCP_SESSION_OPTIONS)),
__param(2, (0, common_1.Inject)(mcp_constants_1.MCP_TRANSPORT_OPTIONS)),
__metadata("design:paramtypes", [Object, Object, Object, registry_service_1.RegistryService,
logger_service_1.McpLoggerService,
session_manager_1.SessionManager])
], SseService);
//# sourceMappingURL=sse.service.js.map