@local-labs-jpollock/local-cli 0.0.1

package/addon-dist/lib/main/mcp/McpAuth.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MCP Authentication Manager
+ * Handles token generation and validation
+ */
+export declare class McpAuth {
+    private token;
+    private logger;
+    constructor(logger: any);
+    /**
+     * Generate a new authentication token
+     */
+    generateToken(): string;
+    /**
+     * Get current token or generate if not exists
+     */
+    getToken(): string;
+    /**
+     * Set token (for loading from saved config)
+     */
+    setToken(token: string): void;
+    /**
+     * Regenerate the authentication token
+     */
+    regenerateToken(): string;
+    /**
+     * Validate provided token against stored token
+     */
+    validateToken(providedToken: string | undefined): boolean;
+    /**
+     * Validate that request comes from trusted IP
+     */
+    validateIP(ip: string | undefined): boolean;
+    /**
+     * Extract Bearer token from Authorization header
+     */
+    extractBearerToken(authHeader: string | undefined): string | undefined;
+}

package/addon-dist/lib/main/mcp/McpAuth.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * MCP Authentication Manager
+ * Handles token generation and validation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpAuth = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const constants_1 = require("../../common/constants");
+class McpAuth {
+    constructor(logger) {
+        this.token = null;
+        this.logger = logger;
+    }
+    /**
+     * Generate a new authentication token
+     */
+    generateToken() {
+        this.token = crypto_1.default.randomBytes(constants_1.AUTH_TOKEN_LENGTH / 2).toString('base64');
+        this.logger.info(`[MCP] Generated new authentication token: ${this.token.substring(0, 20)}...`);
+        return this.token;
+    }
+    /**
+     * Get current token or generate if not exists
+     */
+    getToken() {
+        if (!this.token) {
+            return this.generateToken();
+        }
+        return this.token;
+    }
+    /**
+     * Set token (for loading from saved config)
+     */
+    setToken(token) {
+        this.token = token;
+    }
+    /**
+     * Regenerate the authentication token
+     */
+    regenerateToken() {
+        this.logger.info('[MCP] Regenerating authentication token');
+        return this.generateToken();
+    }
+    /**
+     * Validate provided token against stored token
+     */
+    validateToken(providedToken) {
+        if (!this.token || !providedToken) {
+            this.logger.warn(`[MCP Auth] Validation failed: token=${!!this.token}, provided=${!!providedToken}`);
+            return false;
+        }
+        // Support both raw token and Bearer prefix
+        const rawToken = providedToken.startsWith('Bearer ') ? providedToken.slice(7) : providedToken;
+        const isValid = rawToken === this.token;
+        if (!isValid) {
+            this.logger.warn(`[MCP Auth] Token mismatch: provided=${rawToken.substring(0, 20)}... stored=${this.token.substring(0, 20)}...`);
+        }
+        return isValid;
+    }
+    /**
+     * Validate that request comes from trusted IP
+     */
+    validateIP(ip) {
+        if (!ip) {
+            return false;
+        }
+        return constants_1.TRUSTED_IPS.includes(ip);
+    }
+    /**
+     * Extract Bearer token from Authorization header
+     */
+    extractBearerToken(authHeader) {
+        if (!authHeader) {
+            return undefined;
+        }
+        if (authHeader.startsWith('Bearer ')) {
+            return authHeader.slice(7);
+        }
+        return authHeader;
+    }
+}
+exports.McpAuth = McpAuth;
+//# sourceMappingURL=data:application/json;base64,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

package/addon-dist/lib/main/mcp/McpServer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP Server
+ * Main server class that handles HTTP/SSE connections for MCP protocol
+ */
+import { McpConnectionInfo, McpServerConfig, McpServerStatus, LocalServices } from '../../common/types';
+export declare class McpServer {
+    private server;
+    private port;
+    private auth;
+    private connectionInfo;
+    private services;
+    private logger;
+    private startTime;
+    constructor(config: McpServerConfig, services: LocalServices, logger: any);
+    /**
+     * Start the MCP server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the MCP server
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get server status
+     */
+    getStatus(): McpServerStatus;
+    /**
+     * Get connection info for external tools
+     */
+    getConnectionInfo(): McpConnectionInfo;
+    /**
+     * Regenerate the authentication token
+     */
+    regenerateToken(): Promise<string>;
+    /**
+     * Find an available port starting from the preferred port
+     */
+    private findAvailablePort;
+    /**
+     * Handle incoming HTTP requests
+     */
+    private handleRequest;
+    /**
+     * Handle health check requests
+     */
+    private handleHealth;
+    /**
+     * Handle SSE connection for MCP protocol
+     */
+    private handleSSE;
+    /**
+     * Handle MCP message requests
+     */
+    private handleMessage;
+    /**
+     * Process an MCP message and return response
+     */
+    private processMessage;
+    /**
+     * Send an error response
+     */
+    private sendError;
+}

package/addon-dist/lib/main/mcp/McpServer.js

@@ -0,0 +1,343 @@
+"use strict";
+/**
+ * MCP Server
+ * Main server class that handles HTTP/SSE connections for MCP protocol
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const constants_1 = require("../../common/constants");
+const McpAuth_1 = require("./McpAuth");
+const ConnectionInfo_1 = require("../config/ConnectionInfo");
+const tools_1 = require("./tools");
+class McpServer {
+    constructor(config, services, logger) {
+        this.server = null;
+        this.startTime = 0;
+        this.port = config.port || constants_1.MCP_SERVER.DEFAULT_PORT;
+        this.services = services;
+        this.logger = logger;
+        this.auth = new McpAuth_1.McpAuth(logger);
+        this.connectionInfo = new ConnectionInfo_1.ConnectionInfoManager(logger);
+        // Set token if provided
+        if (config.authToken) {
+            this.auth.setToken(config.authToken);
+        }
+        // Register all tools
+        (0, tools_1.registerTools)();
+    }
+    /**
+     * Start the MCP server
+     */
+    async start() {
+        if (this.server) {
+            this.logger.warn('[MCP] Server already running');
+            return;
+        }
+        // Try to load existing token from connection info (for persistence across restarts)
+        const existingInfo = await this.connectionInfo.load();
+        if (existingInfo?.authToken) {
+            this.auth.setToken(existingInfo.authToken);
+            this.logger.info(`[MCP] Loaded existing auth token: ${existingInfo.authToken.substring(0, 20)}...`);
+        }
+        // Find available port
+        this.port = await this.findAvailablePort(this.port);
+        return new Promise((resolve, reject) => {
+            this.server = http_1.default.createServer((req, res) => this.handleRequest(req, res));
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    this.logger.error(`[MCP] Port ${this.port} is in use`);
+                    reject(new Error(`Port ${this.port} is already in use`));
+                }
+                else {
+                    this.logger.error('[MCP] Server error:', err);
+                    reject(err);
+                }
+            });
+            this.server.listen(this.port, '127.0.0.1', async () => {
+                this.startTime = Date.now();
+                this.logger.info(`[MCP] Server started on http://127.0.0.1:${this.port}`);
+                // Save connection info
+                const info = this.getConnectionInfo();
+                await this.connectionInfo.save(info);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the MCP server
+     */
+    async stop() {
+        if (!this.server) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.logger.info('[MCP] Server stopped');
+                this.server = null;
+                this.connectionInfo.delete();
+                resolve();
+            });
+        });
+    }
+    /**
+     * Check if server is running
+     */
+    isRunning() {
+        return this.server !== null;
+    }
+    /**
+     * Get server status
+     */
+    getStatus() {
+        return {
+            running: this.isRunning(),
+            port: this.port,
+            uptime: this.isRunning() ? (Date.now() - this.startTime) / 1000 : 0,
+        };
+    }
+    /**
+     * Get connection info for external tools
+     */
+    getConnectionInfo() {
+        return {
+            url: `http://127.0.0.1:${this.port}`,
+            authToken: this.auth.getToken(),
+            port: this.port,
+            version: constants_1.MCP_SERVER.VERSION,
+            tools: (0, tools_1.getToolNames)(),
+        };
+    }
+    /**
+     * Regenerate the authentication token
+     */
+    async regenerateToken() {
+        const newToken = this.auth.regenerateToken();
+        // Update connection info file with new token
+        const info = this.getConnectionInfo();
+        await this.connectionInfo.save(info);
+        this.logger.info(`[MCP] Auth token regenerated`);
+        return newToken;
+    }
+    /**
+     * Find an available port starting from the preferred port
+     */
+    async findAvailablePort(preferredPort) {
+        const isPortAvailable = (port) => {
+            return new Promise((resolve) => {
+                const testServer = http_1.default.createServer();
+                testServer.once('error', () => resolve(false));
+                testServer.once('listening', () => {
+                    testServer.close(() => resolve(true));
+                });
+                testServer.listen(port, '127.0.0.1');
+            });
+        };
+        for (let port = preferredPort; port <= constants_1.MCP_SERVER.PORT_RANGE.MAX; port++) {
+            if (await isPortAvailable(port)) {
+                if (port !== preferredPort) {
+                    this.logger.info(`[MCP] Port ${preferredPort} unavailable, using ${port}`);
+                }
+                return port;
+            }
+        }
+        throw new Error(`No available ports in range ${constants_1.MCP_SERVER.PORT_RANGE.MIN}-${constants_1.MCP_SERVER.PORT_RANGE.MAX}`);
+    }
+    /**
+     * Handle incoming HTTP requests
+     */
+    async handleRequest(req, res) {
+        const url = new url_1.URL(req.url || '/', `http://127.0.0.1:${this.port}`);
+        const pathname = url.pathname;
+        // IP check
+        if (!this.auth.validateIP(req.socket.remoteAddress)) {
+            this.sendError(res, 403, 'Forbidden: Only localhost connections allowed');
+            return;
+        }
+        // Health endpoint (no auth required)
+        if (pathname === constants_1.MCP_ENDPOINTS.HEALTH) {
+            this.handleHealth(req, res);
+            return;
+        }
+        // Auth check for all other endpoints
+        const authHeader = req.headers.authorization;
+        if (!this.auth.validateToken(authHeader)) {
+            this.sendError(res, 401, 'Unauthorized: Invalid or missing authentication token');
+            return;
+        }
+        // Handle CORS preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200, {
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                'Access-Control-Max-Age': '86400',
+            });
+            res.end();
+            return;
+        }
+        // Route to appropriate handler
+        if (pathname === constants_1.MCP_ENDPOINTS.SSE && req.method === 'GET') {
+            this.handleSSE(req, res);
+        }
+        else if (pathname === constants_1.MCP_ENDPOINTS.MESSAGES && req.method === 'POST') {
+            await this.handleMessage(req, res);
+        }
+        else {
+            this.sendError(res, 404, 'Not Found');
+        }
+    }
+    /**
+     * Handle health check requests
+     */
+    handleHealth(req, res) {
+        const status = this.getStatus();
+        const token = this.auth.getToken();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            status: 'ok',
+            version: constants_1.MCP_SERVER.VERSION,
+            uptime: status.uptime,
+            tools: (0, tools_1.getToolNames)(),
+            tokenPrefix: token.substring(0, 20),
+        }));
+    }
+    /**
+     * Handle SSE connection for MCP protocol
+     */
+    handleSSE(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        // Send endpoint information
+        const messagesUrl = `http://127.0.0.1:${this.port}${constants_1.MCP_ENDPOINTS.MESSAGES}`;
+        res.write(`event: endpoint\ndata: ${messagesUrl}\n\n`);
+        // Keep connection alive
+        const keepAlive = setInterval(() => {
+            res.write(': keepalive\n\n');
+        }, 30000);
+        req.on('close', () => {
+            clearInterval(keepAlive);
+        });
+    }
+    /**
+     * Handle MCP message requests
+     */
+    async handleMessage(req, res) {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk;
+        });
+        req.on('end', async () => {
+            try {
+                const request = JSON.parse(body);
+                // Notifications don't have an id and don't expect a response
+                if (request.method?.startsWith('notifications/')) {
+                    this.logger.info(`[MCP] Received notification: ${request.method}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end('{}');
+                    return;
+                }
+                const response = await this.processMessage(request);
+                res.writeHead(200, {
+                    'Content-Type': 'application/json',
+                    'Access-Control-Allow-Origin': '*',
+                });
+                res.end(JSON.stringify(response));
+            }
+            catch (error) {
+                this.logger.error('[MCP] Message handling error:', error);
+                this.sendError(res, 400, `Invalid request: ${error.message}`);
+            }
+        });
+    }
+    /**
+     * Process an MCP message and return response
+     */
+    async processMessage(request) {
+        const { id, method, params } = request;
+        switch (method) {
+            case 'initialize':
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        protocolVersion: '2024-11-05',
+                        capabilities: {
+                            tools: {},
+                        },
+                        serverInfo: {
+                            name: constants_1.MCP_SERVER.NAME,
+                            version: constants_1.MCP_SERVER.VERSION,
+                        },
+                    },
+                };
+            case 'tools/list':
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        tools: (0, tools_1.getToolDefinitions)(),
+                    },
+                };
+            case 'tools/call':
+                if (!params?.name) {
+                    return {
+                        jsonrpc: '2.0',
+                        id,
+                        error: {
+                            code: -32602,
+                            message: 'Missing tool name',
+                        },
+                    };
+                }
+                if (!(0, tools_1.hasTool)(params.name)) {
+                    return {
+                        jsonrpc: '2.0',
+                        id,
+                        error: {
+                            code: -32602,
+                            message: `Unknown tool: ${params.name}`,
+                        },
+                    };
+                }
+                const result = await (0, tools_1.executeTool)(params.name, params.arguments || {}, this.services);
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result,
+                };
+            case 'ping':
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {},
+                };
+            default:
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    error: {
+                        code: -32601,
+                        message: `Unknown method: ${method}`,
+                    },
+                };
+        }
+    }
+    /**
+     * Send an error response
+     */
+    sendError(res, statusCode, message) {
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+    }
+}
+exports.McpServer = McpServer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"McpServer.js","sourceRoot":"","sources":["../../../src/main/mcp/McpServer.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MCP Server\n * Main server class that handles HTTP/SSE connections for MCP protocol\n */\n\nimport http from 'http';\nimport { URL } from 'url';\nimport { MCP_SERVER, MCP_ENDPOINTS } from '../../common/constants';\nimport {\n  McpConnectionInfo,\n  McpServerConfig,\n  McpServerStatus,\n  McpRequest,\n  McpResponse,\n  LocalServices,\n} from '../../common/types';\nimport { McpAuth } from './McpAuth';\nimport { ConnectionInfoManager } from '../config/ConnectionInfo';\nimport { registerTools, getToolDefinitions, getToolNames, executeTool, hasTool } from './tools';\n\nexport class McpServer {\n  private server: http.Server | null = null;\n  private port: number;\n  private auth: McpAuth;\n  private connectionInfo: ConnectionInfoManager;\n  private services: LocalServices;\n  private logger: any;\n  private startTime: number = 0;\n\n  constructor(config: McpServerConfig, services: LocalServices, logger: any) {\n    this.port = config.port || MCP_SERVER.DEFAULT_PORT;\n    this.services = services;\n    this.logger = logger;\n    this.auth = new McpAuth(logger);\n    this.connectionInfo = new ConnectionInfoManager(logger);\n\n    // Set token if provided\n    if (config.authToken) {\n      this.auth.setToken(config.authToken);\n    }\n\n    // Register all tools\n    registerTools();\n  }\n\n  /**\n   * Start the MCP server\n   */\n  async start(): Promise<void> {\n    if (this.server) {\n      this.logger.warn('[MCP] Server already running');\n      return;\n    }\n\n    // Try to load existing token from connection info (for persistence across restarts)\n    const existingInfo = await this.connectionInfo.load();\n    if (existingInfo?.authToken) {\n      this.auth.setToken(existingInfo.authToken);\n      this.logger.info(\n        `[MCP] Loaded existing auth token: ${existingInfo.authToken.substring(0, 20)}...`\n      );\n    }\n\n    // Find available port\n    this.port = await this.findAvailablePort(this.port);\n\n    return new Promise((resolve, reject) => {\n      this.server = http.createServer((req, res) => this.handleRequest(req, res));\n\n      this.server.on('error', (err: any) => {\n        if (err.code === 'EADDRINUSE') {\n          this.logger.error(`[MCP] Port ${this.port} is in use`);\n          reject(new Error(`Port ${this.port} is already in use`));\n        } else {\n          this.logger.error('[MCP] Server error:', err);\n          reject(err);\n        }\n      });\n\n      this.server.listen(this.port, '127.0.0.1', async () => {\n        this.startTime = Date.now();\n        this.logger.info(`[MCP] Server started on http://127.0.0.1:${this.port}`);\n\n        // Save connection info\n        const info = this.getConnectionInfo();\n        await this.connectionInfo.save(info);\n\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Stop the MCP server\n   */\n  async stop(): Promise<void> {\n    if (!this.server) {\n      return;\n    }\n\n    return new Promise((resolve) => {\n      this.server!.close(() => {\n        this.logger.info('[MCP] Server stopped');\n        this.server = null;\n        this.connectionInfo.delete();\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Check if server is running\n   */\n  isRunning(): boolean {\n    return this.server !== null;\n  }\n\n  /**\n   * Get server status\n   */\n  getStatus(): McpServerStatus {\n    return {\n      running: this.isRunning(),\n      port: this.port,\n      uptime: this.isRunning() ? (Date.now() - this.startTime) / 1000 : 0,\n    };\n  }\n\n  /**\n   * Get connection info for external tools\n   */\n  getConnectionInfo(): McpConnectionInfo {\n    return {\n      url: `http://127.0.0.1:${this.port}`,\n      authToken: this.auth.getToken(),\n      port: this.port,\n      version: MCP_SERVER.VERSION,\n      tools: getToolNames(),\n    };\n  }\n\n  /**\n   * Regenerate the authentication token\n   */\n  async regenerateToken(): Promise<string> {\n    const newToken = this.auth.regenerateToken();\n    // Update connection info file with new token\n    const info = this.getConnectionInfo();\n    await this.connectionInfo.save(info);\n    this.logger.info(`[MCP] Auth token regenerated`);\n    return newToken;\n  }\n\n  /**\n   * Find an available port starting from the preferred port\n   */\n  private async findAvailablePort(preferredPort: number): Promise<number> {\n    const isPortAvailable = (port: number): Promise<boolean> => {\n      return new Promise((resolve) => {\n        const testServer = http.createServer();\n        testServer.once('error', () => resolve(false));\n        testServer.once('listening', () => {\n          testServer.close(() => resolve(true));\n        });\n        testServer.listen(port, '127.0.0.1');\n      });\n    };\n\n    for (let port = preferredPort; port <= MCP_SERVER.PORT_RANGE.MAX; port++) {\n      if (await isPortAvailable(port)) {\n        if (port !== preferredPort) {\n          this.logger.info(`[MCP] Port ${preferredPort} unavailable, using ${port}`);\n        }\n        return port;\n      }\n    }\n\n    throw new Error(\n      `No available ports in range ${MCP_SERVER.PORT_RANGE.MIN}-${MCP_SERVER.PORT_RANGE.MAX}`\n    );\n  }\n\n  /**\n   * Handle incoming HTTP requests\n   */\n  private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {\n    const url = new URL(req.url || '/', `http://127.0.0.1:${this.port}`);\n    const pathname = url.pathname;\n\n    // IP check\n    if (!this.auth.validateIP(req.socket.remoteAddress)) {\n      this.sendError(res, 403, 'Forbidden: Only localhost connections allowed');\n      return;\n    }\n\n    // Health endpoint (no auth required)\n    if (pathname === MCP_ENDPOINTS.HEALTH) {\n      this.handleHealth(req, res);\n      return;\n    }\n\n    // Auth check for all other endpoints\n    const authHeader = req.headers.authorization;\n    if (!this.auth.validateToken(authHeader)) {\n      this.sendError(res, 401, 'Unauthorized: Invalid or missing authentication token');\n      return;\n    }\n\n    // Handle CORS preflight\n    if (req.method === 'OPTIONS') {\n      res.writeHead(200, {\n        'Access-Control-Allow-Origin': '*',\n        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',\n        'Access-Control-Allow-Headers': 'Content-Type, Authorization',\n        'Access-Control-Max-Age': '86400',\n      });\n      res.end();\n      return;\n    }\n\n    // Route to appropriate handler\n    if (pathname === MCP_ENDPOINTS.SSE && req.method === 'GET') {\n      this.handleSSE(req, res);\n    } else if (pathname === MCP_ENDPOINTS.MESSAGES && req.method === 'POST') {\n      await this.handleMessage(req, res);\n    } else {\n      this.sendError(res, 404, 'Not Found');\n    }\n  }\n\n  /**\n   * Handle health check requests\n   */\n  private handleHealth(req: http.IncomingMessage, res: http.ServerResponse): void {\n    const status = this.getStatus();\n    const token = this.auth.getToken();\n    res.writeHead(200, { 'Content-Type': 'application/json' });\n    res.end(\n      JSON.stringify({\n        status: 'ok',\n        version: MCP_SERVER.VERSION,\n        uptime: status.uptime,\n        tools: getToolNames(),\n        tokenPrefix: token.substring(0, 20),\n      })\n    );\n  }\n\n  /**\n   * Handle SSE connection for MCP protocol\n   */\n  private handleSSE(req: http.IncomingMessage, res: http.ServerResponse): void {\n    res.writeHead(200, {\n      'Content-Type': 'text/event-stream',\n      'Cache-Control': 'no-cache',\n      Connection: 'keep-alive',\n      'Access-Control-Allow-Origin': '*',\n    });\n\n    // Send endpoint information\n    const messagesUrl = `http://127.0.0.1:${this.port}${MCP_ENDPOINTS.MESSAGES}`;\n    res.write(`event: endpoint\\ndata: ${messagesUrl}\\n\\n`);\n\n    // Keep connection alive\n    const keepAlive = setInterval(() => {\n      res.write(': keepalive\\n\\n');\n    }, 30000);\n\n    req.on('close', () => {\n      clearInterval(keepAlive);\n    });\n  }\n\n  /**\n   * Handle MCP message requests\n   */\n  private async handleMessage(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {\n    let body = '';\n\n    req.on('data', (chunk) => {\n      body += chunk;\n    });\n\n    req.on('end', async () => {\n      try {\n        const request: McpRequest = JSON.parse(body);\n\n        // Notifications don't have an id and don't expect a response\n        if (request.method?.startsWith('notifications/')) {\n          this.logger.info(`[MCP] Received notification: ${request.method}`);\n          res.writeHead(200, { 'Content-Type': 'application/json' });\n          res.end('{}');\n          return;\n        }\n\n        const response = await this.processMessage(request);\n\n        res.writeHead(200, {\n          'Content-Type': 'application/json',\n          'Access-Control-Allow-Origin': '*',\n        });\n        res.end(JSON.stringify(response));\n      } catch (error: any) {\n        this.logger.error('[MCP] Message handling error:', error);\n        this.sendError(res, 400, `Invalid request: ${error.message}`);\n      }\n    });\n  }\n\n  /**\n   * Process an MCP message and return response\n   */\n  private async processMessage(request: McpRequest): Promise<McpResponse> {\n    const { id, method, params } = request;\n\n    switch (method) {\n      case 'initialize':\n        return {\n          jsonrpc: '2.0',\n          id,\n          result: {\n            protocolVersion: '2024-11-05',\n            capabilities: {\n              tools: {},\n            },\n            serverInfo: {\n              name: MCP_SERVER.NAME,\n              version: MCP_SERVER.VERSION,\n            },\n          },\n        };\n\n      case 'tools/list':\n        return {\n          jsonrpc: '2.0',\n          id,\n          result: {\n            tools: getToolDefinitions(),\n          },\n        };\n\n      case 'tools/call':\n        if (!params?.name) {\n          return {\n            jsonrpc: '2.0',\n            id,\n            error: {\n              code: -32602,\n              message: 'Missing tool name',\n            },\n          };\n        }\n\n        if (!hasTool(params.name)) {\n          return {\n            jsonrpc: '2.0',\n            id,\n            error: {\n              code: -32602,\n              message: `Unknown tool: ${params.name}`,\n            },\n          };\n        }\n\n        const result = await executeTool(params.name, params.arguments || {}, this.services);\n\n        return {\n          jsonrpc: '2.0',\n          id,\n          result,\n        };\n\n      case 'ping':\n        return {\n          jsonrpc: '2.0',\n          id,\n          result: {},\n        };\n\n      default:\n        return {\n          jsonrpc: '2.0',\n          id,\n          error: {\n            code: -32601,\n            message: `Unknown method: ${method}`,\n          },\n        };\n    }\n  }\n\n  /**\n   * Send an error response\n   */\n  private sendError(res: http.ServerResponse, statusCode: number, message: string): void {\n    res.writeHead(statusCode, { 'Content-Type': 'application/json' });\n    res.end(JSON.stringify({ error: message }));\n  }\n}\n"]}

package/addon-dist/lib/main/mcp/tools/changePhpVersion.d.ts

@@ -0,0 +1,7 @@
+/**
+ * change_php_version Tool
+ * Change PHP version for a site
+ */
+import { McpToolDefinition, McpToolResult, LocalServices } from '../../../common/types';
+export declare const changePhpVersionDefinition: McpToolDefinition;
+export declare function changePhpVersion(args: Record<string, unknown>, services: LocalServices): Promise<McpToolResult>;