devchain-cli 0.1.0

package/dist/server/modules/mcp/controllers/mcp-http.controller.js

@@ -0,0 +1,790 @@
+"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.McpHttpController = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_service_1 = require("../services/mcp.service");
+const crypto_1 = require("crypto");
+const constants_1 = require("../constants");
+const JSONRPC_ERRORS = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+};
+function makeError(id, code, message, data) {
+    const error = { code, message };
+    if (data !== undefined)
+        error.data = data;
+    return { jsonrpc: '2.0', id, error };
+}
+function makeResult(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+function isJsonRpcRequest(msg) {
+    if (!msg || typeof msg !== 'object') {
+        return false;
+    }
+    const record = msg;
+    return record.jsonrpc === '2.0' && typeof record.method === 'string';
+}
+function isNotification(msg) {
+    return !('id' in msg);
+}
+let McpHttpController = class McpHttpController {
+    constructor(mcp) {
+        this.mcp = mcp;
+        this.sessions = new Map();
+    }
+    async handle(payload, reply, _sessionId) {
+        if (Array.isArray(payload)) {
+            const responses = await Promise.all(payload.map((item) => this.handleOne(item, reply)));
+            const filtered = responses.filter((r) => r !== null);
+            if (filtered.length === 0) {
+                reply.status(204);
+                return;
+            }
+            return filtered;
+        }
+        const result = await this.handleOne(payload, reply);
+        if (result === null) {
+            reply.status(204);
+            return;
+        }
+        return result;
+    }
+    async handleOne(msg, reply) {
+        if (!isJsonRpcRequest(msg)) {
+            return makeError(null, JSONRPC_ERRORS.INVALID_REQUEST, 'Invalid Request');
+        }
+        const req = msg;
+        const id = req.id ?? null;
+        try {
+            if (isNotification(req)) {
+                if (req.method === 'notifications/initialized' || req.method === 'initialized') {
+                    return null;
+                }
+                return null;
+            }
+            if (req.method === 'initialize') {
+                const newSessionId = (0, crypto_1.randomUUID)();
+                reply.header('Mcp-Session-Id', newSessionId);
+                const params = req.params;
+                return makeResult(id, {
+                    protocolVersion: params?.protocolVersion ?? '2024-11-05',
+                    capabilities: {
+                        tools: {},
+                        resources: {},
+                        experimental: {
+                            streamableHttp: true,
+                        },
+                    },
+                    serverInfo: {
+                        name: 'devchain-local-app',
+                        version: '0.1.0',
+                    },
+                });
+            }
+            if (req.method === 'tools/list' || req.method === 'tools.list') {
+                return makeResult(id, { tools: this.listTools() });
+            }
+            if (req.method === 'resources/list' || req.method === 'resources.list') {
+                return makeResult(id, { resources: [] });
+            }
+            if (req.method === 'resources/read' || req.method === 'resources.read') {
+                const p = (req.params || {});
+                const uri = p?.uri;
+                if (!uri || typeof uri !== 'string') {
+                    return makeError(id, JSONRPC_ERRORS.INVALID_PARAMS, 'Missing uri');
+                }
+                const resp = await this.mcp.handleResourceRequest(uri);
+                if (resp.success)
+                    return makeResult(id, resp.data ?? null);
+                return makeError(id, JSONRPC_ERRORS.INTERNAL_ERROR, resp.error?.message || 'Error', {
+                    code: resp.error?.code,
+                });
+            }
+            if (req.method === 'tools/call' || req.method === 'tools.call') {
+                const p = (req.params || {});
+                const name = p?.name ?? p?.tool ?? p?.method;
+                const args = p?.arguments ?? p?.params ?? {};
+                if (!name || typeof name !== 'string') {
+                    return makeError(id, JSONRPC_ERRORS.INVALID_PARAMS, 'Missing tool name');
+                }
+                const resp = await this.mcp.handleToolCall(name, args);
+                if (resp.success)
+                    return makeResult(id, {
+                        content: [{ type: 'text', text: JSON.stringify(resp.data ?? null, null, 2) }],
+                        isError: false,
+                    });
+                return makeError(id, JSONRPC_ERRORS.INTERNAL_ERROR, resp.error?.message || 'Error', {
+                    code: resp.error?.code,
+                });
+            }
+            const resp = await this.mcp.handleToolCall(req.method, req.params ?? {});
+            if (resp.success)
+                return makeResult(id, resp.data ?? null);
+            return makeError(id, JSONRPC_ERRORS.INTERNAL_ERROR, resp.error?.message || 'Error', {
+                code: resp.error?.code,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Internal error';
+            return makeError(id, JSONRPC_ERRORS.INTERNAL_ERROR, message);
+        }
+    }
+    listTools() {
+        const tools = [
+            {
+                name: 'devchain_list_documents',
+                description: 'List all documents for the current project. Automatically scopes to the project at the provided path.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to current working directory (e.g. /home/user/project)',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Filter by tags (all must match)',
+                        },
+                        q: { type: 'string', description: 'Search query for title/content' },
+                        limit: { type: 'number', description: 'Max results (default: 100)' },
+                        offset: { type: 'number', description: 'Pagination offset (default: 0)' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_activity_start',
+                description: 'Start an activity for an agent; posts a system start message and begins a running timer (DM by default).',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'agentName', 'title'],
+                    properties: {
+                        path: { type: 'string', description: 'Absolute project path' },
+                        agentName: { type: 'string', description: 'Agent name (case-insensitive)' },
+                        title: { type: 'string', description: 'Activity title (<=256 chars)' },
+                        threadId: { type: 'string', description: 'Target thread UUID (optional)' },
+                        announce: { type: 'boolean', description: 'Whether to post the start system message' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_activity_finish',
+                description: 'Finish the latest running activity for an agent; optionally posts a finish system message.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'agentName'],
+                    properties: {
+                        path: { type: 'string', description: 'Absolute project path' },
+                        agentName: { type: 'string', description: 'Agent name (case-insensitive)' },
+                        threadId: { type: 'string', description: 'Target thread UUID (optional)' },
+                        message: { type: 'string', description: 'Optional finish message (<=1000 chars)' },
+                        status: {
+                            type: 'string',
+                            enum: ['success', 'failed', 'canceled'],
+                            description: 'Final status (default success)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_get_document',
+                description: 'Get a single document by ID or slug, with optional link resolution',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Document UUID' },
+                        slug: { type: 'string', description: 'Document slug (requires projectId)' },
+                        projectId: { type: 'string', description: 'Project ID when using slug' },
+                        includeLinks: {
+                            type: 'string',
+                            enum: ['none', 'meta', 'inline'],
+                            description: 'Link resolution: none (no links), meta (link metadata), inline (full content)',
+                        },
+                        maxDepth: {
+                            type: 'number',
+                            description: 'Max depth for inline resolution (default: 1)',
+                        },
+                        maxBytes: {
+                            type: 'number',
+                            description: 'Max bytes for inline content (default: 64KB)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_create_document',
+                description: 'Create a new markdown document in the project at the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'title', 'contentMd'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to current working directory (e.g. /home/user/project)',
+                        },
+                        title: { type: 'string', description: 'Document title' },
+                        contentMd: { type: 'string', description: 'Markdown content' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Document tags' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_update_document',
+                description: 'Update an existing document',
+                inputSchema: {
+                    type: 'object',
+                    required: ['id'],
+                    properties: {
+                        id: { type: 'string', description: 'Document UUID' },
+                        title: { type: 'string', description: 'New title' },
+                        slug: { type: 'string', description: 'New slug' },
+                        contentMd: { type: 'string', description: 'New markdown content' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'New tags' },
+                        archived: { type: 'boolean', description: 'Archive status' },
+                        version: { type: 'number', description: 'Version for optimistic locking' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_list_prompts',
+                description: 'List prompts for the project resolved from the provided path (projectId deprecated)',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        projectId: { type: 'string', description: '[deprecated] Filter by project ID' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' },
+                        q: { type: 'string', description: 'Search query' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_get_prompt',
+                description: 'Get a specific prompt by ID or by (name + path)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Prompt UUID' },
+                        name: { type: 'string', description: 'Prompt name/title' },
+                        version: { type: 'number', description: 'Specific version number' },
+                        path: {
+                            type: 'string',
+                            description: 'Absolute project path required when querying by name (e.g. /home/user/project)',
+                        },
+                        projectId: {
+                            type: 'string',
+                            description: '[deprecated] Project ID for scoped prompts',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_list_agents',
+                description: 'List agents for the project resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        limit: { type: 'number', description: 'Max results (default: 100)' },
+                        offset: { type: 'number', description: 'Pagination offset (default: 0)' },
+                        q: {
+                            type: 'string',
+                            description: 'Optional case-insensitive substring filter on agent name',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_get_agent_by_name',
+                description: 'Fetch a single agent by name for the project resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'name'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Agent name to look up (case-insensitive match)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_list_statuses',
+                description: 'List project statuses resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_list_epics',
+                description: 'List epics for the project resolved from the provided path with optional filters',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        statusName: {
+                            type: 'string',
+                            description: 'Optional status name filter (case-insensitive)',
+                        },
+                        limit: { type: 'number', description: 'Max results (default: 100)' },
+                        offset: { type: 'number', description: 'Pagination offset (default: 0)' },
+                        q: {
+                            type: 'string',
+                            description: 'Optional search query applied to epic titles and descriptions',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_list_assigned_epics_tasks',
+                description: 'List epics assigned to the specified agent within the project resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'agentName'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        agentName: { type: 'string', description: 'Agent name to match (case-insensitive)' },
+                        limit: { type: 'number', description: 'Max results (default: 100)' },
+                        offset: { type: 'number', description: 'Pagination offset (default: 0)' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_create_epic',
+                description: 'Create a new epic within the project resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'title'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        title: { type: 'string', description: 'Epic title' },
+                        description: { type: 'string', description: 'Optional epic description' },
+                        statusName: {
+                            type: 'string',
+                            description: 'Optional status name (case-insensitive)',
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Optional list of tags to assign to the epic',
+                        },
+                        agentName: {
+                            type: 'string',
+                            description: 'Optional agent name to assign (case-insensitive)',
+                        },
+                        parentId: {
+                            type: 'string',
+                            description: 'Optional parent epic UUID to nest this epic under',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_get_epic_by_id',
+                description: 'Fetch a single epic, including comments and related hierarchy details',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'id'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        id: { type: 'string', description: 'Epic UUID' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_add_epic_comment',
+                description: 'Add a comment to the specified epic within the project resolved from the provided path',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'epicId', 'authorName', 'content'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        epicId: { type: 'string', description: 'Epic UUID' },
+                        authorName: { type: 'string', description: 'Name of the comment author' },
+                        content: { type: 'string', description: 'Comment body content' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_update_epic',
+                description: 'Update an epic with flexible field updates including status (by name), assignment (by agent name or clear), parent hierarchy, and tags. Uses optimistic locking via version.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'id', 'version'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        id: { type: 'string', description: 'Epic UUID' },
+                        version: { type: 'number', description: 'Current version for optimistic locking' },
+                        title: { type: 'string', description: 'New epic title' },
+                        description: { type: 'string', description: 'New epic description' },
+                        statusName: {
+                            type: 'string',
+                            description: 'Status name (case-insensitive exact match)',
+                        },
+                        assignment: {
+                            type: 'object',
+                            description: 'Assignment update: either { agentName: string } to assign or { clear: true } to unassign',
+                            oneOf: [
+                                {
+                                    type: 'object',
+                                    required: ['agentName'],
+                                    properties: {
+                                        agentName: {
+                                            type: 'string',
+                                            description: 'Agent name (case-insensitive exact match)',
+                                        },
+                                    },
+                                },
+                                {
+                                    type: 'object',
+                                    required: ['clear'],
+                                    properties: {
+                                        clear: {
+                                            type: 'boolean',
+                                            const: true,
+                                            description: 'Set to true to clear assignment',
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                        parentId: {
+                            type: 'string',
+                            description: 'Parent epic UUID (mutually exclusive with clearParent)',
+                        },
+                        clearParent: {
+                            type: 'boolean',
+                            description: 'Set to true to remove parent (mutually exclusive with parentId)',
+                        },
+                        setTags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Replace all tags with this array',
+                        },
+                        addTags: { type: 'array', items: { type: 'string' }, description: 'Tags to add' },
+                        removeTags: { type: 'array', items: { type: 'string' }, description: 'Tags to remove' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_create_record',
+                description: 'Create a new record (generic data storage for epics)',
+                inputSchema: {
+                    type: 'object',
+                    required: ['epicId', 'type', 'data'],
+                    properties: {
+                        epicId: { type: 'string', description: 'Epic UUID this record belongs to' },
+                        type: { type: 'string', description: 'Record type identifier' },
+                        data: { type: 'object', description: 'Arbitrary JSON data' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Record tags' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_update_record',
+                description: 'Update an existing record',
+                inputSchema: {
+                    type: 'object',
+                    required: ['id', 'version'],
+                    properties: {
+                        id: { type: 'string', description: 'Record UUID' },
+                        data: { type: 'object', description: 'New data (merged)' },
+                        type: { type: 'string', description: 'New type' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'New tags' },
+                        version: { type: 'number', description: 'Current version for optimistic locking' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_get_record',
+                description: 'Get a record by ID',
+                inputSchema: {
+                    type: 'object',
+                    required: ['id'],
+                    properties: { id: { type: 'string', description: 'Record UUID' } },
+                },
+            },
+            {
+                name: 'devchain_list_records',
+                description: 'List records for an epic with optional filtering',
+                inputSchema: {
+                    type: 'object',
+                    required: ['epicId'],
+                    properties: {
+                        epicId: { type: 'string', description: 'Epic UUID' },
+                        type: { type: 'string', description: 'Filter by record type' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags' },
+                        limit: { type: 'number', description: 'Max results' },
+                        offset: { type: 'number', description: 'Pagination offset' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_add_tags',
+                description: 'Add tags to a record',
+                inputSchema: {
+                    type: 'object',
+                    required: ['id', 'tags'],
+                    properties: {
+                        id: { type: 'string', description: 'Record UUID' },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 1,
+                            description: 'Tags to add',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_remove_tags',
+                description: 'Remove tags from a record',
+                inputSchema: {
+                    type: 'object',
+                    required: ['id', 'tags'],
+                    properties: {
+                        id: { type: 'string', description: 'Record UUID' },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            minItems: 1,
+                            description: 'Tags to remove',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_send_message',
+                description: 'Send a chat message. Provide threadId to reply in a thread, or recipientAgentNames to create a new agent-initiated group when a senderName is provided.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['path', 'message'],
+                    properties: {
+                        path: {
+                            type: 'string',
+                            description: 'Absolute path to the project root (e.g. /home/user/project)',
+                        },
+                        threadId: {
+                            type: 'string',
+                            description: 'Existing thread UUID. When provided with senderName, recipients may be omitted to fan-out to thread members.',
+                        },
+                        recipientAgentNames: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Agent names (case-insensitive) to receive the message. Required only when creating a new thread (no threadId).',
+                        },
+                        recipient: {
+                            type: 'string',
+                            enum: ['user', 'agents'],
+                            description: 'Set to "user" to DM the user without a threadId when providing agentName.',
+                        },
+                        message: { type: 'string', description: 'Message content to deliver.' },
+                        senderName: {
+                            type: 'string',
+                            description: "Agent's name authoring the message (case-insensitive). When provided, message is authored as that agent.",
+                        },
+                        agentName: {
+                            type: 'string',
+                            description: 'Alias for senderName used with { recipient: "user" } to identify the sending agent.',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_chat_ack',
+                description: 'Mark a chat message as read for an agent and emit a message.read event.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['thread_id', 'message_id', 'agent_name'],
+                    properties: {
+                        thread_id: { type: 'string', description: 'Chat thread UUID.' },
+                        message_id: { type: 'string', description: 'Chat message UUID to acknowledge.' },
+                        agent_name: { type: 'string', description: 'Agent name acknowledging the message.' },
+                    },
+                },
+            },
+            {
+                name: 'devchain_chat_read_history',
+                description: 'Fetch recent messages for a chat thread so agents can catch up after an invite.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['thread_id'],
+                    properties: {
+                        thread_id: { type: 'string', description: 'Chat thread UUID.' },
+                        limit: { type: 'number', description: 'Max messages to return (default 50, max 200).' },
+                        since: {
+                            type: 'string',
+                            description: 'ISO timestamp; only messages after this time are returned.',
+                        },
+                        exclude_system: {
+                            type: 'boolean',
+                            description: 'Exclude system messages. Defaults to true when omitted to show only user/agent authored messages.',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'devchain_chat_list_members',
+                description: 'List members of a chat thread along with their online status.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['thread_id'],
+                    properties: { thread_id: { type: 'string', description: 'Chat thread UUID.' } },
+                },
+            },
+        ];
+        return (0, constants_1.filterHiddenTools)(tools);
+    }
+    async handleSseStream(request, reply, sessionId, _lastEventId) {
+        reply.raw.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'X-Accel-Buffering': 'no',
+        });
+        if (sessionId) {
+            const existing = this.sessions.get(sessionId);
+            if (existing) {
+                clearInterval(existing.pingInterval);
+                this.sessions.delete(sessionId);
+            }
+            const pingInterval = setInterval(() => {
+                try {
+                    reply.raw.write(': ping\n\n');
+                }
+                catch (error) {
+                    clearInterval(pingInterval);
+                    this.sessions.delete(sessionId);
+                }
+            }, 30000);
+            this.sessions.set(sessionId, { reply, pingInterval });
+            request.raw.on('close', () => {
+                clearInterval(pingInterval);
+                this.sessions.delete(sessionId);
+            });
+            this.sendSseMessage(reply, 'endpoint', { message: 'SSE connection established' });
+        }
+        return new Promise(() => {
+        });
+    }
+    sendSseMessage(reply, event, data, id) {
+        try {
+            if (id) {
+                reply.raw.write(`id: ${id}\n`);
+            }
+            reply.raw.write(`event: ${event}\n`);
+            reply.raw.write(`data: ${JSON.stringify(data)}\n\n`);
+        }
+        catch (error) {
+        }
+    }
+    sendToSession(sessionId, event, data, id) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            this.sendSseMessage(session.reply, event, data, id);
+            return true;
+        }
+        return false;
+    }
+    async handleDelete(reply, sessionId) {
+        if (sessionId) {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                clearInterval(session.pingInterval);
+                this.sessions.delete(sessionId);
+                return { success: true };
+            }
+        }
+        return { success: false };
+    }
+};
+exports.McpHttpController = McpHttpController;
+__decorate([
+    (0, common_1.Post)(),
+    (0, common_1.HttpCode)(200),
+    __param(0, (0, common_1.Body)()),
+    __param(1, (0, common_1.Res)({ passthrough: true })),
+    __param(2, (0, common_1.Headers)('mcp-session-id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, String]),
+    __metadata("design:returntype", Promise)
+], McpHttpController.prototype, "handle", null);
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __param(2, (0, common_1.Headers)('mcp-session-id')),
+    __param(3, (0, common_1.Headers)('last-event-id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, String, String]),
+    __metadata("design:returntype", Promise)
+], McpHttpController.prototype, "handleSseStream", null);
+__decorate([
+    (0, common_1.Delete)(),
+    (0, common_1.HttpCode)(200),
+    __param(0, (0, common_1.Res)({ passthrough: true })),
+    __param(1, (0, common_1.Headers)('mcp-session-id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], McpHttpController.prototype, "handleDelete", null);
+exports.McpHttpController = McpHttpController = __decorate([
+    (0, common_1.Controller)('mcp/rpc'),
+    __metadata("design:paramtypes", [mcp_service_1.McpService])
+], McpHttpController);
+//# sourceMappingURL=mcp-http.controller.js.map