@theupsider/lsp-mcp 0.1.0

package/dist/lsp/__tests__/lsp-client.test.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_events_1 = require("node:events");
+const node_stream_1 = require("node:stream");
+const lsp_client_1 = require("../lsp-client");
+jest.mock('node:child_process', () => ({
+    spawn: jest.fn()
+}));
+class MockChildProcess extends node_events_1.EventEmitter {
+    stdinWrites = [];
+    stdout = new node_stream_1.PassThrough();
+    stderr = new node_stream_1.PassThrough();
+    stdin = new node_stream_1.Writable({
+        write: (chunk, _encoding, callback) => {
+            this.stdinWrites.push(chunk.toString());
+            callback();
+        }
+    });
+    kill = jest.fn();
+}
+const SERVER = {
+    cmd: 'typescript-language-server',
+    args: ['--stdio'],
+    pkg: 'typescript-language-server',
+    mgr: 'npm'
+};
+describe('LspClient', () => {
+    beforeEach(() => {
+        jest.useRealTimers();
+        jest.clearAllMocks();
+    });
+    it('starts the server, sends initialize, and becomes ready after initialize response', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        const startPromise = client.start();
+        const initializeMessage = extractMessage(child.stdinWrites[0]);
+        expect(initializeMessage.method).toBe('initialize');
+        expect(getObject(initializeMessage.params).workspaceFolders).toEqual([
+            { uri: 'file:///workspace/project', name: 'project' }
+        ]);
+        child.stdout.write(encodeMessage({
+            jsonrpc: '2.0',
+            id: initializeMessage.id,
+            result: { capabilities: { hoverProvider: true } }
+        }));
+        await startPromise;
+        expect(client.isReady()).toBe(true);
+        const initializedMessage = extractMessage(child.stdinWrites[1]);
+        expect(initializedMessage.method).toBe('initialized');
+        expect(initializedMessage.params).toEqual({});
+    });
+    it('sends framed JSON-RPC requests and resolves matching responses', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const hoverPromise = client.request('textDocument/hover', {
+            textDocument: { uri: 'file:///workspace/project/src/index.ts' },
+            position: { line: 0, character: 1 }
+        }, 1000);
+        const hoverRequest = extractMessage(child.stdinWrites[2]);
+        expect(child.stdinWrites[2]).toMatch(/^Content-Length: \d+\r\n\r\n\{/);
+        expect(hoverRequest.method).toBe('textDocument/hover');
+        child.stdout.write(encodeMessage({
+            jsonrpc: '2.0',
+            id: hoverRequest.id,
+            result: { contents: 'hover text' }
+        }));
+        await expect(hoverPromise).resolves.toEqual({ contents: 'hover text' });
+        expect(client.getCapabilities()).toEqual({ hoverProvider: true });
+    });
+    it('rejects requests that exceed their timeout', async () => {
+        jest.useFakeTimers();
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const hoverPromise = client.request('textDocument/hover', {}, 250);
+        const expectation = expect(hoverPromise).rejects.toThrow('LSP request timed out: textDocument/hover');
+        await jest.advanceTimersByTimeAsync(250);
+        await expectation;
+    });
+    it('parses multibyte JSON-RPC payloads using byte-length framing', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const hoverPromise = client.request('textDocument/hover', {
+            textDocument: { uri: 'file:///workspace/project/src/index.ts' },
+            position: { line: 0, character: 1 }
+        }, 1000);
+        const hoverRequest = extractMessage(child.stdinWrites[2]);
+        child.stdout.emit('data', encodeMessage({
+            jsonrpc: '2.0',
+            id: hoverRequest.id,
+            result: { contents: 'Grüße 👋' }
+        }));
+        await expect(hoverPromise).resolves.toEqual({ contents: 'Grüße 👋' });
+    });
+    it('emits crash when the server exits unexpectedly', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const crashPromise = onceErrorEvent(client, 'crash');
+        child.emit('exit', 9, null);
+        await expect(crashPromise).resolves.toThrow('LSP server exited unexpectedly');
+        expect(client.isReady()).toBe(false);
+    });
+    it('rejects requests when the server returns a JSON-RPC error response', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const hoverPromise = client.request('textDocument/hover', {}, 1000);
+        const hoverRequest = extractMessage(child.stdinWrites[2]);
+        child.stdout.write(encodeMessage({
+            jsonrpc: '2.0',
+            id: hoverRequest.id,
+            error: { code: -32603, message: 'hover failed' }
+        }));
+        await expect(hoverPromise).rejects.toThrow('hover failed');
+    });
+    it('emits error when the child process reports an error', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const errorPromise = onceErrorEvent(client, 'error');
+        child.emit('error', new Error('spawn failed'));
+        await expect(errorPromise).resolves.toThrow('spawn failed');
+    });
+    it('emits error when a message arrives without a content length header', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const errorPromise = onceErrorEvent(client, 'error');
+        child.stdout.write('X-Test: 1\r\n\r\n{}');
+        await expect(errorPromise).resolves.toThrow('Missing Content-Length header');
+    });
+    it('shuts down gracefully and kills the process if it does not exit in time', async () => {
+        jest.useFakeTimers();
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const shutdownPromise = client.shutdown();
+        const shutdownRequest = extractMessage(child.stdinWrites[2]);
+        expect(shutdownRequest.method).toBe('shutdown');
+        child.stdout.write(encodeMessage({
+            jsonrpc: '2.0',
+            id: shutdownRequest.id,
+            result: null
+        }));
+        await shutdownPromise;
+        expect(extractMessage(child.stdinWrites[3]).method).toBe('exit');
+        await jest.advanceTimersByTimeAsync(5000);
+        expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+    });
+    it('does not emit crash after an expected shutdown exit', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        const crashListener = jest.fn();
+        client.on('crash', crashListener);
+        const shutdownPromise = client.shutdown();
+        const shutdownRequest = extractMessage(child.stdinWrites[2]);
+        child.stdout.write(encodeMessage({ jsonrpc: '2.0', id: shutdownRequest.id, result: null }));
+        await shutdownPromise;
+        child.emit('exit', 0, null);
+        expect(crashListener).not.toHaveBeenCalled();
+    });
+    it('does not spawn a second process when start is called twice', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await startClient(client, child);
+        await client.start();
+        expect(spawn).toHaveBeenCalledTimes(1);
+    });
+    it('handles notifications, idle shutdown, and missing process writes safely', async () => {
+        const child = new MockChildProcess();
+        const spawn = jest.requireMock('node:child_process').spawn;
+        spawn.mockReturnValue(child);
+        const client = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        const freshClient = new lsp_client_1.LspClient(SERVER, '/workspace/project', 'debug');
+        await expect(freshClient.shutdown()).resolves.toBeUndefined();
+        expect(() => freshClient.notify('initialized', {})).toThrow('LSP process is not running');
+        await expect(freshClient.request('textDocument/hover', {}, 1000)).rejects.toThrow('LSP process is not running');
+        await startClient(client, child);
+        const notificationPromise = new Promise((resolve) => {
+            client.once('notification', (method, params) => resolve({ method, params }));
+        });
+        child.stdout.write(encodeMessage({ jsonrpc: '2.0', method: 'textDocument/publishDiagnostics', params: { uri: 'file:///x', diagnostics: [] } }));
+        await expect(notificationPromise).resolves.toEqual({ method: 'textDocument/publishDiagnostics', params: { uri: 'file:///x', diagnostics: [] } });
+    });
+});
+function encodeMessage(payload) {
+    const body = JSON.stringify(payload);
+    return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
+}
+function extractMessage(raw) {
+    const [, body = ''] = raw.split('\r\n\r\n');
+    return JSON.parse(body);
+}
+function getObject(value) {
+    expect(value).toBeDefined();
+    return value;
+}
+async function startClient(client, child) {
+    const startPromise = client.start();
+    const initializeMessage = extractMessage(child.stdinWrites[0]);
+    child.stdout.write(encodeMessage({
+        jsonrpc: '2.0',
+        id: initializeMessage.id,
+        result: { capabilities: { hoverProvider: true } }
+    }));
+    await startPromise;
+}
+function onceErrorEvent(emitter, eventName) {
+    return new Promise((resolve) => {
+        emitter.once(eventName, (error) => resolve(error));
+    });
+}

package/dist/lsp/installer.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installLsp = installLsp;
+const node_child_process_1 = require("node:child_process");
+async function installLsp(candidate) {
+    const command = getInstallCommand(candidate);
+    if (!command) {
+        return {
+            success: false,
+            error: `Automatic user-local install is not supported for ${candidate.mgr}`,
+            instructions: getManualInstructions(candidate)
+        };
+    }
+    return await new Promise((resolve) => {
+        (0, node_child_process_1.exec)(command, { env: process.env }, (error) => {
+            if (error) {
+                resolve({
+                    success: false,
+                    error: error.message,
+                    instructions: getManualInstructions(candidate)
+                });
+                return;
+            }
+            resolve({ success: true });
+        });
+    });
+}
+function getInstallCommand(candidate) {
+    switch (candidate.mgr) {
+        case 'npm':
+            return `npm install --global --prefix "$HOME/.local" ${candidate.pkg}`;
+        case 'pip':
+            return `pip install --user ${candidate.pkg}`;
+        case 'go':
+            return `go install ${candidate.pkg}@latest`;
+        case 'gem':
+            return `gem install --user-install ${candidate.pkg}`;
+        case 'cargo':
+            return `cargo install ${candidate.pkg}`;
+        default:
+            return null;
+    }
+}
+function getManualInstructions(candidate) {
+    switch (candidate.mgr) {
+        case 'npm':
+            return `npm install -g ${candidate.pkg}`;
+        case 'pip':
+            return `pip install ${candidate.pkg}`;
+        case 'go':
+            return `go install ${candidate.pkg}@latest`;
+        case 'gem':
+            return `gem install ${candidate.pkg}`;
+        case 'cargo':
+            return `cargo install ${candidate.pkg}`;
+        case 'dotnet':
+            return `dotnet tool install -g ${candidate.pkg}`;
+        case 'apt':
+            return `sudo apt install ${candidate.pkg}`;
+        case 'brew':
+            return `brew install ${candidate.pkg}`;
+        default:
+            return `${candidate.mgr} install ${candidate.pkg}`;
+    }
+}

package/dist/lsp/lifecycle-manager.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleManager = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const language_detector_1 = require("../detection/language-detector");
+const lsp_mapping_1 = require("../detection/lsp-mapping");
+const uri_1 = require("../utils/uri");
+const installer_1 = require("./installer");
+const lsp_client_1 = require("./lsp-client");
+const EXTENSION_LANGUAGE_MAP = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.py': 'python',
+    '.cs': 'csharp',
+    '.java': 'java',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.c': 'c',
+    '.h': 'c',
+    '.cpp': 'cpp',
+    '.hpp': 'cpp',
+    '.cc': 'cpp',
+    '.rb': 'ruby',
+    '.php': 'php',
+    '.kt': 'kotlin',
+    '.swift': 'swift'
+};
+class LifecycleManager {
+    projectRoot;
+    logLevel;
+    states = new Map();
+    diagnostics = new Map();
+    constructor(projectRoot, logLevel) {
+        this.projectRoot = projectRoot;
+        this.logLevel = normalizeLogLevel(logLevel);
+    }
+    async start(languages) {
+        const startPromise = this.startInternal(languages);
+        await promiseWithTimeout(startPromise, 30000, 'Lifecycle start timed out');
+    }
+    async ensureLanguage(language) {
+        if (this.states.has(language)) {
+            return;
+        }
+        const state = {
+            language,
+            client: null,
+            status: 'starting',
+            serverDef: null,
+            restartCount: 0,
+            healthInterval: null
+        };
+        this.states.set(language, state);
+        await this.startLanguage(state);
+    }
+    async ensureLanguageForFile(filePath) {
+        const language = EXTENSION_LANGUAGE_MAP[node_path_1.default.extname(filePath).toLowerCase()];
+        if (language) {
+            await this.ensureLanguage(language);
+        }
+    }
+    getClient(language) {
+        return this.states.get(language)?.client ?? null;
+    }
+    getClientForFile(filePath) {
+        const language = EXTENSION_LANGUAGE_MAP[node_path_1.default.extname(filePath).toLowerCase()];
+        if (language) {
+            return this.getClient(language);
+        }
+        return null;
+    }
+    getHealth() {
+        return Array.from(this.states.values()).map((state) => ({
+            language: state.language,
+            status: state.status,
+            error: state.error,
+            capabilities: state.capabilities
+        }));
+    }
+    getReadyClients(language) {
+        return Array.from(this.states.values())
+            .filter((state) => state.status === 'ready' && state.client && (!language || state.language === language))
+            .flatMap((state) => state.client ? [state.client] : []);
+    }
+    getFileDiagnostics(filePath) {
+        const uri = (0, uri_1.pathToUri)(filePath);
+        return (this.diagnostics.get(uri) ?? []).map((diagnostic) => ({ ...diagnostic, uri }));
+    }
+    getWorkspaceDiagnostics(language) {
+        const allowedExtensions = language
+            ? Object.entries(EXTENSION_LANGUAGE_MAP)
+                .filter(([, mappedLanguage]) => mappedLanguage === language)
+                .map(([extension]) => extension)
+            : null;
+        return Array.from(this.diagnostics.entries())
+            .filter(([uri]) => {
+            if (!allowedExtensions) {
+                return true;
+            }
+            return allowedExtensions.includes(node_path_1.default.extname((0, uri_1.uriToPath)(uri)).toLowerCase());
+        })
+            .flatMap(([uri, diagnostics]) => diagnostics.map((diagnostic) => ({ ...diagnostic, uri })))
+            .sort((left, right) => (left.severity ?? 4) - (right.severity ?? 4));
+    }
+    async shutdown() {
+        const clients = Array.from(this.states.values()).flatMap((state) => {
+            if (state.healthInterval) {
+                clearInterval(state.healthInterval);
+                state.healthInterval = null;
+            }
+            return state.client ? [state.client] : [];
+        });
+        const results = await Promise.allSettled(clients.map(async (client) => await promiseWithTimeout(client.shutdown(), 5000, 'LSP shutdown timed out')));
+        const errors = results.filter((result) => result.status === 'rejected').length;
+        process.stderr.write(`{"timestamp":"${new Date().toISOString()}","level":"info","event":"Shutdown: ${clients.length - errors} LSP-Server beendet, ${errors} Fehler"}\n`);
+    }
+    async startInternal(languages) {
+        const detected = languages
+            ? languages.map((language) => ({ language }))
+            : await (0, language_detector_1.detectLanguages)(this.projectRoot);
+        for (const entry of detected) {
+            const state = {
+                language: entry.language,
+                client: null,
+                status: 'starting',
+                serverDef: null,
+                restartCount: 0,
+                healthInterval: null
+            };
+            this.states.set(entry.language, state);
+            await this.startLanguage(state);
+        }
+    }
+    async startLanguage(state) {
+        const serverDef = await this.resolveServer(state.language);
+        if (!serverDef) {
+            state.status = 'error';
+            state.error = `No LSP server available for ${state.language}`;
+            return;
+        }
+        state.serverDef = serverDef;
+        const client = new lsp_client_1.LspClient(serverDef, this.projectRoot, this.logLevel);
+        state.client = client;
+        client.on('crash', async () => {
+            await this.restartLanguage(state, `LSP server crashed for ${state.language}`);
+        });
+        client.on('error', (error) => {
+            state.status = 'error';
+            state.error = error instanceof Error ? error.message : 'Unknown LSP error';
+        });
+        client.on('notification', (method, params) => {
+            if (method === 'textDocument/publishDiagnostics') {
+                this.storeDiagnostics(params);
+            }
+        });
+        try {
+            await client.start();
+            state.status = 'ready';
+            state.error = undefined;
+            state.capabilities = client.getCapabilities() ?? undefined;
+            this.startHealthChecks(state);
+        }
+        catch (error) {
+            state.status = 'error';
+            state.error = error instanceof Error ? error.message : 'Unknown LSP startup error';
+        }
+    }
+    startHealthChecks(state) {
+        if (state.healthInterval) {
+            clearInterval(state.healthInterval);
+        }
+        state.healthInterval = setInterval(() => {
+            void this.runHealthCheck(state);
+        }, 30000);
+    }
+    async runHealthCheck(state) {
+        if (!state.client || state.status !== 'ready') {
+            return;
+        }
+        try {
+            await state.client.request('workspace/symbol', { query: '__lsp_mcp_healthcheck__' }, 5000);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'LSP health check failed';
+            await this.restartLanguage(state, message);
+        }
+    }
+    async restartLanguage(state, reason) {
+        if (state.healthInterval) {
+            clearInterval(state.healthInterval);
+            state.healthInterval = null;
+        }
+        if (state.restartCount >= 3) {
+            state.status = 'error';
+            state.error = reason;
+            state.client = null;
+            return;
+        }
+        state.restartCount += 1;
+        state.status = 'starting';
+        state.error = reason;
+        if (state.client) {
+            try {
+                await promiseWithTimeout(state.client.shutdown(), 5000, 'LSP shutdown timed out');
+            }
+            catch {
+                // Ignore shutdown failures during restart.
+            }
+        }
+        state.client = null;
+        await this.startLanguage(state);
+    }
+    async resolveServer(language) {
+        const available = await (0, lsp_mapping_1.findAvailableLsp)(language);
+        if (available) {
+            return available;
+        }
+        const candidate = (0, lsp_mapping_1.getLspCandidates)(language)[0] ?? null;
+        if (!candidate) {
+            return null;
+        }
+        const installation = await (0, installer_1.installLsp)(candidate);
+        if (!installation.success) {
+            return null;
+        }
+        return candidate;
+    }
+    storeDiagnostics(params) {
+        if (!isPublishDiagnosticsParams(params)) {
+            return;
+        }
+        this.diagnostics.set(params.uri, cloneDiagnostics(params.diagnostics));
+    }
+}
+exports.LifecycleManager = LifecycleManager;
+function normalizeLogLevel(level) {
+    if (level === 'error' || level === 'debug') {
+        return level;
+    }
+    return 'info';
+}
+function isPublishDiagnosticsParams(value) {
+    return typeof value === 'object' && value !== null
+        && 'uri' in value && typeof value.uri === 'string'
+        && 'diagnostics' in value && Array.isArray(value.diagnostics);
+}
+function cloneDiagnostics(diagnostics) {
+    return diagnostics.map((diagnostic) => ({
+        ...diagnostic,
+        range: {
+            start: { ...diagnostic.range.start },
+            end: { ...diagnostic.range.end }
+        }
+    }));
+}
+async function promiseWithTimeout(promise, timeoutMs, message) {
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}