@hailer/mcp 0.0.1

package/dist/mcp-server.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * MCPServerService - Handles Express app, routes, and HTTP server management
+ *
+ * Implements JSON-RPC 2.0 MCP protocol over HTTP with Server-Sent Events (SSE)
+ * for LLM clients (Claude Desktop, etc.)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPServerService = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const logger_1 = require("./lib/logger");
+const config_1 = require("./config");
+const UserContextCache_1 = require("./mcp/UserContextCache");
+const tool_registry_1 = require("./mcp/tool-registry");
+class MCPServerService {
+    app;
+    server;
+    logger;
+    config;
+    toolRegistry; // ← Injected
+    constructor(config) {
+        this.config = config;
+        this.toolRegistry = config.toolRegistry;
+        this.logger = (0, logger_1.createLogger)({
+            component: 'mcp-server',
+            service: 'hailer-mcp-server'
+        });
+        this.app = (0, express_1.default)();
+        this.setupMiddleware();
+        this.setupRoutes();
+        this.logger.info('MCP Server initialized', {
+            port: config.port,
+            corsOrigins: config.corsOrigins
+        });
+    }
+    setupMiddleware() {
+        // Configure CORS - empty array means allow all origins (like original cors())
+        if (this.config.corsOrigins.length === 0) {
+            this.app.use((0, cors_1.default)());
+        }
+        else {
+            this.app.use((0, cors_1.default)({
+                origin: this.config.corsOrigins
+            }));
+        }
+        this.app.use(express_1.default.json());
+        // Request logging middleware (skip health endpoint to reduce noise)
+        this.app.use((req, res, next) => {
+            const isHealthCheck = req.path === '/health';
+            const start = Date.now();
+            const requestLogger = this.logger.child({
+                requestId: `req-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+                method: req.method,
+                path: req.path
+            });
+            if (!isHealthCheck) {
+                requestLogger.debug('Incoming request', {
+                    url: req.url,
+                    headers: req.headers['content-type'],
+                    userAgent: req.headers['user-agent']
+                });
+                res.on('finish', () => {
+                    const duration = Date.now() - start;
+                    requestLogger.info('Request completed', {
+                        statusCode: res.statusCode,
+                        duration
+                    });
+                });
+            }
+            // Add logger to request for route handlers
+            req.logger = requestLogger;
+            next();
+        });
+    }
+    setupRoutes() {
+        const appConfig = (0, config_1.createApplicationConfig)();
+        // Health check endpoint (no logging - too noisy)
+        this.app.get('/health', (_, res) => {
+            const health = {
+                status: 'ok',
+                timestamp: new Date().toISOString(),
+                service: 'hailer-mcp-server',
+                version: '0.1.0'
+            };
+            res.json(health);
+        });
+        // MCP Protocol endpoint - JSON-RPC 2.0 over SSE
+        this.app.post('/api/mcp', async (req, res) => {
+            req.logger.debug('MCP request received', { method: req.body?.method });
+            try {
+                const apiKey = req.query.apiKey;
+                const mcpRequest = req.body;
+                let result;
+                if (mcpRequest.method === 'tools/list') {
+                    req.logger.debug('Handling tools/list request');
+                    // Get agent configuration for filtering
+                    let filterConfig;
+                    if (apiKey) {
+                        try {
+                            const agentConfig = appConfig.getClientConfig(apiKey);
+                            if (agentConfig.allowedTools || agentConfig.allowedGroups) {
+                                filterConfig = {
+                                    allowedTools: agentConfig.allowedTools,
+                                    allowedGroups: agentConfig.allowedGroups
+                                };
+                            }
+                        }
+                        catch {
+                            req.logger.debug('No config found for apiKey, returning all tools');
+                        }
+                    }
+                    // Apply NUCLEAR tools blocking if NOT explicitly enabled
+                    if (!config_1.environment.ENABLE_NUCLEAR_TOOLS) {
+                        if (!filterConfig) {
+                            // No filter yet - create one excluding NUCLEAR
+                            filterConfig = {
+                                allowedGroups: [tool_registry_1.ToolGroup.READ, tool_registry_1.ToolGroup.WRITE, tool_registry_1.ToolGroup.PLAYGROUND]
+                            };
+                        }
+                        else if (filterConfig.allowedGroups) {
+                            // Filter has groups - remove NUCLEAR if present
+                            filterConfig.allowedGroups = filterConfig.allowedGroups.filter(g => g !== tool_registry_1.ToolGroup.NUCLEAR);
+                        }
+                        // Note: If filter has explicit allowedTools list, NUCLEAR tools won't be in it anyway
+                        req.logger.debug('NUCLEAR tools blocked (not explicitly enabled)');
+                    }
+                    else {
+                        req.logger.debug('NUCLEAR tools enabled by environment variable');
+                    }
+                    result = {
+                        tools: this.toolRegistry.getToolDefinitions(filterConfig)
+                    };
+                }
+                else if (mcpRequest.method === 'tools/get_schema') {
+                    const toolName = mcpRequest.params?.name;
+                    req.logger.debug('Handling tools/get_schema request', { toolName });
+                    if (!toolName) {
+                        return this.sendMcpError(res, mcpRequest.id, -32602, 'Tool name required in params.name', 400);
+                    }
+                    const schema = this.toolRegistry.getToolSchema(toolName);
+                    if (!schema) {
+                        return this.sendMcpError(res, mcpRequest.id, -32602, `Tool not found: ${toolName}`, 404);
+                    }
+                    result = schema;
+                }
+                else if (mcpRequest.method === 'tools/call') {
+                    if (!apiKey) {
+                        return this.sendMcpError(res, mcpRequest.id, -32602, 'API key required for tools/call', 400);
+                    }
+                    const { name, arguments: args = {} } = mcpRequest.params;
+                    req.logger.debug('Handling tools/call request', { toolName: name });
+                    // Check access control
+                    if (!this.canAccessTool(name, apiKey, appConfig)) {
+                        return this.sendMcpError(res, mcpRequest.id, -32603, `Access denied to tool: ${name}`, 403);
+                    }
+                    const userContext = await UserContextCache_1.UserContextCache.getContext(apiKey);
+                    result = await this.toolRegistry.executeTool(name, args, userContext);
+                }
+                else if (mcpRequest.method === 'initialize') {
+                    req.logger.info('MCP initialize request received');
+                    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+                    res.setHeader('Mcp-Session-Id', sessionId);
+                    result = {
+                        protocolVersion: '2024-11-05',
+                        capabilities: { tools: {} },
+                        serverInfo: {
+                            name: 'hailer-mcp-server',
+                            version: '1.0.0'
+                        }
+                    };
+                }
+                else if (mcpRequest.method === 'notifications/initialized') {
+                    req.logger.info('MCP handshake completed - client initialized');
+                    res.setHeader('Content-Type', 'text/event-stream');
+                    res.status(204).end();
+                    return;
+                }
+                else {
+                    return this.sendMcpError(res, mcpRequest.id, -32601, `Method not found: ${mcpRequest.method}`, 400);
+                }
+                // Send success response
+                const response = {
+                    jsonrpc: '2.0',
+                    result,
+                    id: mcpRequest.id
+                };
+                res.setHeader('Content-Type', 'text/event-stream');
+                res.setHeader('Cache-Control', 'no-cache');
+                res.setHeader('Connection', 'keep-alive');
+                res.write(`data: ${JSON.stringify(response)}\n\n`);
+                res.end();
+            }
+            catch (error) {
+                req.logger.error('MCP handler error', error, { apiKey: req.query.apiKey });
+                this.sendMcpError(res, req.body?.id || null, -32000, `Server error: ${error instanceof Error ? error.message : String(error)}`, 500);
+            }
+        });
+        this.logger.info('Routes configured', {
+            routes: [
+                '/health - Server health check',
+                '/api/mcp - MCP protocol (JSON-RPC 2.0)'
+            ]
+        });
+    }
+    /**
+     * Check if agent has access to a specific tool
+     */
+    canAccessTool(toolName, apiKey, appConfig) {
+        try {
+            const agentConfig = appConfig.getClientConfig(apiKey);
+            // Explicit tool whitelist (takes precedence)
+            if (agentConfig.allowedTools) {
+                return agentConfig.allowedTools.includes(toolName);
+            }
+            // Group-based access control
+            if (agentConfig.allowedGroups) {
+                const tool = this.toolRegistry.getTool(toolName);
+                return tool ? agentConfig.allowedGroups.includes(tool.group) : false;
+            }
+            // Default: allow all (backward compatible)
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Send MCP error response
+     */
+    sendMcpError(res, id, code, message, httpStatus) {
+        const errorResponse = {
+            jsonrpc: '2.0',
+            error: { code, message },
+            id
+        };
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.status(httpStatus).write(`data: ${JSON.stringify(errorResponse)}\n\n`);
+        res.end();
+    }
+    async start() {
+        const { port } = this.config;
+        return new Promise((resolve, reject) => {
+            this.server = this.app.listen(port, () => {
+                this.logger.info('MCP Server started', {
+                    port: port,
+                    healthCheck: `http://localhost:${port}/health`,
+                    mcpEndpoint: `http://localhost:${port}/api/mcp`
+                });
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                this.logger.error('MCP Server error', error);
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        if (this.server) {
+            const server = this.server;
+            return new Promise((resolve) => {
+                server.close(() => {
+                    this.logger.info('MCP Server stopped gracefully');
+                    resolve();
+                });
+            });
+        }
+    }
+    getApp() {
+        return this.app;
+    }
+    isRunning() {
+        return !!this.server?.listening;
+    }
+}
+exports.MCPServerService = MCPServerService;
+//# sourceMappingURL=mcp-server.js.map

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@hailer/mcp",
+  "version": "0.0.1",
+  "config": {
+    "docker": {
+      "registry": "registry.gitlab.com/hailer-repos/hailer-mcp"
+    }
+  },
+  "scripts": {
+    "dev": "tsx watch src/app.ts",
+    "claude-code-mcp": "DISABLE_CLIENT=true tsx src/app.ts",
+    "start-mcp-only": "DISABLE_CLIENT=true tsx src/app.ts",
+    "start-client-only": "DISABLE_MCP_SERVER=true tsx src/app.ts",
+    "build": "tsc",
+    "start": "node dist/app.js",
+    "lint": "eslint src/",
+    "build-dev-push": "rm -rf build/docker-dev && docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):dev -f ./Dockerfile.dev .",
+    "build-debug-push": "docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-debug -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):debug -f ./Dockerfile.debug .",
+    "build-prod-push": "rm -rf build/docker-prod && docker build --target artifacts --output build/docker-prod . -f Dockerfile.build-prod && docker buildx build --push --platform linux/amd64,linux/arm64/v8 -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):prod -f ./Dockerfile.prod .",
+    "build-k3d": "docker build -f Dockerfile.debug . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs) -c hailer",
+    "build-k3d-dummy": "docker build --target artifacts --output build/docker-dev . -f Dockerfile.build-dev && docker build -f Dockerfile.dev . -t $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev && k3d image import $(npm pkg get config.docker.registry | xargs)/$(npm pkg get name | xargs):$(npm pkg get version | xargs)-dev -c hailer",
+    "mcp-server": "hailer-mcp"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.54.0",
+    "@hailer/cli": "^1.1.10",
+    "@modelcontextprotocol/sdk": "^1.11.5",
+    "@opentelemetry/api-logs": "^0.57.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "^0.57.0",
+    "@opentelemetry/resources": "^1.28.0",
+    "@opentelemetry/sdk-logs": "^0.57.0",
+    "@opentelemetry/sdk-node": "^0.57.0",
+    "@opentelemetry/semantic-conventions": "^1.36.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.5.0",
+    "express": "^4.21.2",
+    "form-data": "^4.0.4",
+    "openai": "^5.5.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^20.19.1",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "eslint": "^9.29.0",
+    "globals": "^16.2.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5"
+  },
+  "bin": {
+    "hailer-mcp": "dist/cli.js"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "CommonJS", 
+    "moduleResolution": "node",
+    "types": ["node"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "baseUrl": "."
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}