Multiple language client support to support MCP Server

Signed-off-by: azerr <azerr@redhat.com>

Author: angelozerr

package.json

@@ -190,6 +190,12 @@
           "description": "The XML Language server allows other VSCode extensions to extend its functionality. It requires Java-specific features in order to do this. If extensions to the XML language server are detected, but a binary XML language server is run, a warning will appear. This setting can be used to disable this warning.",
           "scope": "window"
         },
+        "xml.mcp.enabled": {
+          "type": "boolean",
+          "default": false,
+          "markdownDescription": "Enable MCP (Model Context Protocol) server mode. When enabled, the XML language server runs in socket mode and registers itself in `~/.languagetools/instances.json`, allowing MCP servers (like languagetools) to connect and share the same server instance. Requires restart to take effect.",
+          "scope": "window"
+        },
         "xml.server.binary.path": {
           "type": "string",
           "description": "Specify the path of a custom binary version of the XML server to use. A binary will be downloaded if this is not set.",

src/client/xmlClient.ts

@@ -1,7 +1,7 @@
 import { TelemetryEvent } from '@redhat-developer/vscode-redhat-telemetry/lib';
 import { commands, ExtensionContext, extensions, Position, TextDocument, TextEditor, Uri, window, workspace } from 'vscode';
 import { Command, ConfigurationParams, ConfigurationRequest, DidChangeConfigurationNotification, DocumentFilter, DocumentSelector, ExecuteCommandParams, LanguageClientOptions, MessageType, NotificationType, RequestType, RevealOutputChannelOn, State, TextDocumentPositionParams } from "vscode-languageclient";
-import { Executable, LanguageClient } from 'vscode-languageclient/node';
+import { Executable, LanguageClient, ServerOptions } from 'vscode-languageclient/node';
 import { XMLFileAssociation } from '../api/xmlExtensionApi';
 import { registerClientServerCommands } from '../commands/registerCommands';
 import * as ServerCommandConstants from '../commands/serverCommandConstants';
@@ -41,10 +41,10 @@ const ActionableNotification = new NotificationType<ActionableMessage>('xml/acti
 
 let languageClient: LanguageClient;
 
-export async function startLanguageClient(context: ExtensionContext, executable: Executable, logfile: string, externalXmlSettings: ExternalXmlSettings, requirementsData: RequirementsData): Promise<LanguageClient> {
+export async function startLanguageClient(context: ExtensionContext, serverOptions: ServerOptions, logfile: string, externalXmlSettings: ExternalXmlSettings, requirementsData: RequirementsData): Promise<LanguageClient> {
 
   const languageClientOptions: LanguageClientOptions = getLanguageClientOptions(logfile, externalXmlSettings, requirementsData, context);
-  languageClient = new LanguageClient('xml', 'XML Support', executable, languageClientOptions);
+  languageClient = new LanguageClient('xml', 'XML Support', serverOptions, languageClientOptions);
   //In vscode-languageclient version 9.0.0, inline completion (textDocument/inlineCompletion) is a proposed feature
   // TODO remove registerProposedFeatures once upgraded to 10.x
   languageClient.registerProposedFeatures();

src/extension.ts

@@ -12,7 +12,7 @@
 
 import * as fs from 'fs-extra';
 import { ConfigurationTarget, ExtensionContext, Uri, commands, extensions, languages, window, workspace } from "vscode";
-import { Executable, LanguageClient } from 'vscode-languageclient/node';
+import { Executable, LanguageClient, ServerOptions } from 'vscode-languageclient/node';
 import { XMLExtensionApi } from './api/xmlExtensionApi';
 import { getXmlExtensionApiImplementation } from './api/xmlExtensionApiImplementation';
 import { cleanUpHeapDumps } from './client/clientErrorHandler';
@@ -67,7 +67,7 @@ export async function activate(context: ExtensionContext): Promise<XMLExtensionA
 
   const externalXmlSettings: ExternalXmlSettings = new ExternalXmlSettings();
 
-  const serverOptions: Executable = await prepareExecutable(
+  const serverOptions: ServerOptions = await prepareExecutable(
     requirementsData, collectXmlJavaExtensions(extensions.all, getXMLConfiguration().get("extension.jars", [])), context);
 
   languageClient = await startLanguageClient(context, serverOptions, logfile, externalXmlSettings, requirementsData);

src/server/binary/binaryServerStarter.ts

@@ -6,7 +6,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { Readable } from 'stream';
 import { commands, ExtensionContext, extensions, ProgressLocation, ProgressOptions, window, WorkspaceConfiguration } from "vscode";
-import { Executable } from "vscode-languageclient/node";
+import { Executable, ServerOptions } from "vscode-languageclient/node";
 import * as yauzl from 'yauzl';
 import * as ClientCommandConstants from '../../commands/clientCommandConstants';
 import { getProxySettings, getProxySettingsAsEnvironmentVariables, ProxySettings } from '../../settings/proxySettings';
@@ -21,13 +21,13 @@ const JAR_ZIP_AND_HASH_REJECTOR = /(?:\.jar)|(?:\.zip)|(?:\.sha256)$/;
 export const ABORTED_ERROR: Error = new Error('XML Language Server download cancelled by user');
 
 /**
- * Returns the executable to launch LemMinX (the XML Language Server) as a binary
+ * Returns the server options to launch LemMinX (the XML Language Server) as a binary
  *
  * @param context the extension context
  * @throws if the binary doesn't exist and can't be downloaded, or if the binary is not trusted
- * @returns Returns the executable to launch LemMinX (the XML Language Server) as a binary
+ * @returns Returns the server options to launch LemMinX (the XML Language Server) as a binary
  */
-export async function prepareBinaryExecutable(context: ExtensionContext): Promise<Executable> {
+export async function prepareBinaryExecutable(context: ExtensionContext): Promise<ServerOptions> {
   const binaryArgs: string = getXMLConfiguration().get("server.binary.args");
   let binaryExecutable: Executable;
   return getServerBinaryPath()

src/server/java/javaServerStarter.ts

@@ -1,7 +1,7 @@
 import * as os from 'os';
 import * as path from 'path';
 import { ExtensionContext, window, workspace } from 'vscode';
-import { Executable } from 'vscode-languageclient/node';
+import { Executable, ServerOptions } from 'vscode-languageclient/node';
 import { getProxySettings, getProxySettingsAsJVMArgs, jvmArgsContainsProxySettings, ProxySettings } from '../../settings/proxySettings';
 import { getJavaagentFlag, getKey, getXMLConfiguration, IS_WORKSPACE_VMARGS_XML_ALLOWED, xmlServerVmargs } from '../../settings/settings';
 import { RequirementsData } from '../requirements';
@@ -17,15 +17,19 @@ export async function prepareJavaExecutable(
   context: ExtensionContext,
   requirements: RequirementsData,
   xmlJavaExtensions: string[]
-): Promise<Executable> {
+): Promise<ServerOptions> {
 
+  const mcpEnabled = getXMLConfiguration().get('mcp.enabled', false);
+  const workspacePath = workspace.workspaceFolders?.[0]?.uri.fsPath || '';
+
+  // Always use stdio mode, but pass MCP parameters if enabled
   return {
     command: path.resolve(requirements.java_home + '/bin/java'),
-    args: prepareParams(requirements, xmlJavaExtensions, context)
+    args: prepareParams(requirements, xmlJavaExtensions, context, mcpEnabled, workspacePath)
   } as Executable;
 }
 
-function prepareParams(requirements: RequirementsData, xmlJavaExtensions: string[], context: ExtensionContext): string[] {
+function prepareParams(requirements: RequirementsData, xmlJavaExtensions: string[], context: ExtensionContext, mcpEnabled?: boolean, workspacePath?: string): string[] {
   const params: string[] = [];
   if (DEBUG) {
     if (process.env['SUSPEND_SERVER'] === 'true') {
@@ -96,7 +100,15 @@ function prepareParams(requirements: RequirementsData, xmlJavaExtensions: string
       xmlJavaExtensionsClasspath = pathSeparator + xmlJavaExtensions.join(pathSeparator);
     }
     params.push('-cp'); params.push(path.resolve(server_home, launchersFound[0]) + xmlJavaExtensionsClasspath);
+
+    // Always use stdio launcher
     params.push('org.eclipse.lemminx.XMLServerLauncher');
+
+    // Add MCP arguments if enabled
+    if (mcpEnabled && workspacePath) {
+      params.push('--mcp-enabled');
+      params.push('--workspace'); params.push(workspacePath);
+    }
   } else {
     return null;
   }
@@ -135,3 +147,5 @@ export function parseVMargs(params: any[], vmargsLine: string) {
     }
   });
 }
+
+

src/server/serverStarter.ts

@@ -1,24 +1,24 @@
 import { commands, ConfigurationTarget, ExtensionContext, window } from "vscode";
-import { Executable } from "vscode-languageclient/node";
+import { Executable, ServerOptions } from "vscode-languageclient/node";
 import { getXMLConfiguration } from "../settings/settings";
 import * as Telemetry from "../telemetry";
 import { ABORTED_ERROR, prepareBinaryExecutable } from "./binary/binaryServerStarter";
 import { prepareJavaExecutable } from "./java/javaServerStarter";
 import { getOpenJDKDownloadLink, RequirementsData } from "./requirements";
 
 /**
- * Returns the executable to use to launch LemMinX (the XML Language Server)
+ * Returns the server options to use to launch LemMinX (the XML Language Server)
  *
  * @param requirements the java information, or an empty object if there is no java
  * @param xmlJavaExtensions a list of all the java extension jars
  * @param context the extensions context
  * @throws if neither the binary nor the java version of the extension can be launched
- * @returns the executable to launch LemMinX with (the XML language server)
+ * @returns the server options to launch LemMinX with (the XML language server)
  */
 export async function prepareExecutable(
   requirements: RequirementsData,
   xmlJavaExtensions: string[],
-  context: ExtensionContext): Promise<Executable> {
+  context: ExtensionContext): Promise<ServerOptions> {
 
   const hasJava: boolean = requirements.java_home !== undefined;
   const hasExtensions: boolean = xmlJavaExtensions.length !== 0;