@theia/ai-mcp-server 1.65.0

package/src/node/mcp-theia-server-impl.ts

@@ -0,0 +1,241 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core/lib/common/logger';
+import { BackendApplicationContribution } from '@theia/core/lib/node/backend-application';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { generateUuid } from '@theia/core';
+
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp';
+import * as express from '@theia/core/shared/express';
+import { randomUUID } from 'crypto';
+import { MCPTheiaServer } from './mcp-theia-server';
+import { MCPBackendContributionManager } from './mcp-backend-contribution-manager';
+import { MCPFrontendContributionManager } from './mcp-frontend-contribution-manager';
+
+@injectable()
+export class MCPTheiaServerImpl implements MCPTheiaServer, BackendApplicationContribution {
+
+    @inject(ILogger)
+    protected readonly logger: ILogger;
+
+    @inject(MCPBackendContributionManager)
+    protected readonly backendContributionManager: MCPBackendContributionManager;
+
+    @inject(MCPFrontendContributionManager)
+    protected readonly frontendContributionManager: MCPFrontendContributionManager;
+
+    protected server?: McpServer;
+    protected httpTransports: Map<string, StreamableHTTPServerTransport> = new Map();
+    protected httpApp?: express.Application;
+    protected running = false;
+    protected serverId: string = generateUuid();
+
+    async configure?(app: express.Application): Promise<void> {
+        this.httpApp = app;
+
+        try {
+            await this.start();
+        } catch (error) {
+            this.logger.error('Failed to start MCP server during initialization:', error);
+        }
+    }
+
+    async start(): Promise<void> {
+        if (this.running) {
+            throw new Error('MCP server is already running');
+        }
+
+        this.server = new McpServer({
+            name: 'Theia MCP Server',
+            version: '1.0.0'
+        }, {
+            capabilities: {
+                tools: {
+                    listChanged: true
+                },
+                resources: {
+                    listChanged: true
+                },
+                prompts: {
+                    listChanged: true
+                }
+            }
+        });
+
+        await this.registerContributions();
+        await this.setupHttpTransport();
+
+        this.running = true;
+    }
+
+    async stop(): Promise<void> {
+        if (!this.running) {
+            return;
+        }
+
+        try {
+            if (this.serverId) {
+                await this.frontendContributionManager.unregisterFrontendContributions(this.serverId);
+            }
+
+            for (const transport of this.httpTransports.values()) {
+                transport.close();
+            }
+            this.httpTransports.clear();
+
+            if (this.server) {
+                this.server.close();
+                this.server = undefined;
+            }
+
+            this.running = false;
+        } catch (error) {
+            this.logger.error('Error stopping MCP server:', error);
+            throw error;
+        }
+    }
+
+    getServer(): McpServer | undefined {
+        return this.server;
+    }
+
+    isRunning(): boolean {
+        return this.running;
+    }
+
+    getServerId(): string | undefined {
+        return this.serverId;
+    }
+
+    protected async setupHttpTransport(): Promise<void> {
+        if (!this.server) {
+            throw new Error('Server not initialized');
+        }
+        if (!this.httpApp) {
+            throw new Error('AppServer not initialized');
+        }
+
+        this.setupHttpEndpoints(this.httpApp);
+    }
+
+    protected setupHttpEndpoints(app: express.Application): void {
+        app.all('/mcp', async (req, res) => {
+            await this.handleStreamableHttpRequest(req, res);
+        });
+    }
+
+    protected async handleStreamableHttpRequest(req: express.Request, res: express.Response): Promise<void> {
+        if (!this.server) {
+            res.status(503).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'MCP Server not initialized',
+                },
+                id: undefined,
+            });
+            return;
+        }
+
+        const sessionId = req.headers['mcp-session-id'] as string | undefined;
+        let transport: StreamableHTTPServerTransport;
+
+        try {
+            if (sessionId && this.httpTransports.has(sessionId)) {
+                transport = this.httpTransports.get(sessionId)!;
+            } else {
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: newSessionId => {
+                        this.httpTransports.set(newSessionId, transport);
+                    }
+                });
+
+                transport.onclose = () => {
+                    if (transport.sessionId) {
+                        this.httpTransports.delete(transport.sessionId);
+                    }
+                };
+
+                await this.server.connect(transport);
+            }
+
+            await transport.handleRequest(req, res, req.body);
+        } catch (error) {
+            this.logger.error('Error handling MCP Streamable HTTP request:', error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: `Internal server error: ${error}`,
+                    },
+                    id: req.body?.id || undefined,
+                });
+            }
+        }
+    }
+
+    protected async registerContributions(): Promise<void> {
+        if (!this.server) {
+            throw new Error('Server not initialized');
+        }
+
+        await this.backendContributionManager.registerBackendContributions(this.server);
+        await this.registerFrontendContributions();
+    }
+
+    protected async registerFrontendContributions(): Promise<void> {
+        if (!this.server) {
+            throw new Error('Server not initialized');
+        }
+
+        try {
+            await this.frontendContributionManager.setMCPServer(this.server, this.serverId);
+        } catch (error) {
+            this.logger.debug('Frontend contributions registration failed (this is normal if no frontend is connected):', error);
+        }
+    }
+
+    onStop(): void {
+        this.logger.debug('MCP Server stopping...');
+
+        if (this.running) {
+            try {
+                if (this.serverId) {
+                    this.frontendContributionManager.unregisterFrontendContributions(this.serverId)
+                        .catch(error => this.logger.warn('Failed to unregister frontend contributions during shutdown:', error));
+                }
+
+                for (const transport of this.httpTransports.values()) {
+                    transport.close();
+                }
+                this.httpTransports.clear();
+
+                if (this.server) {
+                    this.server.close();
+                    this.server = undefined;
+                }
+
+                this.running = false;
+            } catch (error) {
+                this.logger.error('Error stopping MCP server:', error);
+            }
+        }
+    }
+}

package/src/node/mcp-theia-server.ts

@@ -0,0 +1,66 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+
+export const MCPTheiaServer = Symbol('MCPTheiaServer');
+
+/**
+ * Main interface for the Theia MCP server (backend only)
+ */
+export interface MCPTheiaServer {
+    /**
+     * Start the MCP server with the given configuration
+     */
+    start(): Promise<void>;
+
+    /**
+     * Stop the MCP server
+     */
+    stop(): Promise<void>;
+
+    /**
+     * Get the underlying MCP server instance
+     */
+    getServer(): McpServer | undefined;
+
+    /**
+     * Get the server ID
+     */
+    getServerId(): string | undefined;
+
+    /**
+     * Check if the server is running
+     */
+    isRunning(): boolean;
+}
+
+export const MCPBackendContribution = Symbol('MCPBackendContribution');
+
+/**
+ * Contribution interface for extending the MCP server with backend-only contributions
+ */
+export interface MCPBackendContribution {
+    /**
+     * Configure MCP server (for backend contributions)
+     * @param server The MCP server instance to configure
+     */
+    configure(server: McpServer): Promise<void> | void;
+}
+
+export const MCPBackendContributionProvider = Symbol('MCPBackendContributionProvider');
+export interface MCPBackendContributionProvider extends ContributionProvider<MCPBackendContribution> { }

package/src/node/mcp-tool-frontend-delegate.ts

@@ -0,0 +1,71 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable } from '@theia/core/shared/inversify';
+import { Tool, Resource, ResourceContents, Prompt, PromptMessage } from '@modelcontextprotocol/sdk/types';
+import { MCPToolFrontendDelegate, MCPToolDelegateClient } from '../common/mcp-tool-delegate';
+
+@injectable()
+export class MCPToolFrontendDelegateImpl implements MCPToolFrontendDelegate {
+
+    private client?: MCPToolDelegateClient;
+
+    setClient(client: MCPToolDelegateClient): void {
+        this.client = client;
+    }
+
+    async callTool(serverId: string, toolName: string, args: unknown): Promise<unknown> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.callTool(serverId, toolName, args);
+    }
+
+    async listTools(serverId: string): Promise<Tool[]> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.listTools(serverId);
+    }
+
+    async listResources(serverId: string): Promise<Resource[]> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.listResources(serverId);
+    }
+
+    async readResource(serverId: string, uri: string): Promise<ResourceContents> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.readResource(serverId, uri);
+    }
+
+    async listPrompts(serverId: string): Promise<Prompt[]> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.listPrompts(serverId);
+    }
+
+    async getPrompt(serverId: string, name: string, args: unknown): Promise<PromptMessage[]> {
+        if (!this.client) {
+            throw new Error('MCPToolDelegateClient not set');
+        }
+        return this.client.getPrompt(serverId, name, args);
+    }
+}

package/src/package.spec.ts

@@ -0,0 +1,28 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/* note: this bogus test file is required so that
+   we are able to run mocha unit tests on this
+   package, without having any actual unit tests in it.
+   This way a coverage report will be generated,
+   showing 0% coverage, instead of no report.
+   This file can be removed once we have real unit
+   tests in place. */
+
+describe('ai-mcp-server package', () => {
+
+    it('support code coverage statistics', () => true);
+});