thaddeus 1.0.26 → 1.0.28

package/src/services/lsp/LSPServerInstance.js

@@ -0,0 +1,388 @@
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { getCwd } from '../../utils/cwd.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { sleep } from '../../utils/sleep.js';
+/**
+ * LSP error code for "content modified" - indicates the server's state changed
+ * during request processing (e.g., rust-analyzer still indexing the project).
+ * This is a transient error that can be retried.
+ */
+const LSP_ERROR_CONTENT_MODIFIED = -32801;
+/**
+ * Maximum number of retries for transient LSP errors like "content modified".
+ */
+const MAX_RETRIES_FOR_TRANSIENT_ERRORS = 3;
+/**
+ * Base delay in milliseconds for exponential backoff on transient errors.
+ * Actual delays: 500ms, 1000ms, 2000ms
+ */
+const RETRY_BASE_DELAY_MS = 500;
+/**
+ * Creates and manages a single LSP server instance.
+ *
+ * Uses factory function pattern with closures for state encapsulation (avoiding classes).
+ * Provides state tracking, health monitoring, and request forwarding for an LSP server.
+ * Supports manual restart with configurable retry limits.
+ *
+ * State machine transitions:
+ * - stopped → starting → running
+ * - running → stopping → stopped
+ * - any → error (on failure)
+ * - error → starting (on retry)
+ *
+ * @param name - Unique identifier for this server instance
+ * @param config - Server configuration including command, args, and limits
+ * @returns LSP server instance with lifecycle management methods
+ *
+ * @example
+ * const instance = createLSPServerInstance('my-server', config)
+ * await instance.start()
+ * const result = await instance.sendRequest('textDocument/definition', params)
+ * await instance.stop()
+ */
+export function createLSPServerInstance(name, config) {
+    // Validate that unimplemented fields are not set
+    if (config.restartOnCrash !== undefined) {
+        throw new Error(`LSP server '${name}': restartOnCrash is not yet implemented. Remove this field from the configuration.`);
+    }
+    if (config.shutdownTimeout !== undefined) {
+        throw new Error(`LSP server '${name}': shutdownTimeout is not yet implemented. Remove this field from the configuration.`);
+    }
+    // Private state encapsulated via closures. Lazy-require LSPClient so
+    // vscode-jsonrpc (~129KB) only loads when an LSP server is actually
+    // instantiated, not when the static import chain reaches this module.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { createLSPClient } = require('./LSPClient.js');
+    let state = 'stopped';
+    let startTime;
+    let lastError;
+    let restartCount = 0;
+    let crashRecoveryCount = 0;
+    // Propagate crash state so ensureServerStarted can restart on next use.
+    // Without this, state stays 'running' after crash and the server is never
+    // restarted (zombie state).
+    const client = createLSPClient(name, error => {
+        state = 'error';
+        lastError = error;
+        crashRecoveryCount++;
+    });
+    /**
+     * Starts the LSP server and initializes it with workspace information.
+     *
+     * If the server is already running or starting, this method returns immediately.
+     * On failure, sets state to 'error', logs for monitoring, and throws.
+     *
+     * @throws {Error} If server fails to start or initialize
+     */
+    async function start() {
+        if (state === 'running' || state === 'starting') {
+            return;
+        }
+        // Cap crash-recovery attempts so a persistently crashing server doesn't
+        // spawn unbounded child processes on every incoming request.
+        const maxRestarts = config.maxRestarts ?? 3;
+        if (state === 'error' && crashRecoveryCount > maxRestarts) {
+            const error = new Error(`LSP server '${name}' exceeded max crash recovery attempts (${maxRestarts})`);
+            lastError = error;
+            logError(error);
+            throw error;
+        }
+        let initPromise;
+        try {
+            state = 'starting';
+            logForDebugging(`Starting LSP server instance: ${name}`);
+            // Start the client
+            await client.start(config.command, config.args || [], {
+                env: config.env,
+                cwd: config.workspaceFolder,
+            });
+            // Initialize with workspace info
+            const workspaceFolder = config.workspaceFolder || getCwd();
+            const workspaceUri = pathToFileURL(workspaceFolder).href;
+            const initParams = {
+                processId: process.pid,
+                // Pass server-specific initialization options from plugin config
+                // Required by vue-language-server, optional for others
+                // Provide empty object as default to avoid undefined errors in servers
+                // that expect this field to exist
+                initializationOptions: config.initializationOptions ?? {},
+                // Modern approach (LSP 3.16+) - required for Pyright, gopls
+                workspaceFolders: [
+                    {
+                        uri: workspaceUri,
+                        name: path.basename(workspaceFolder),
+                    },
+                ],
+                // Deprecated fields - some servers still need these for proper URI resolution
+                rootPath: workspaceFolder, // Deprecated in LSP 3.8 but needed by some servers
+                rootUri: workspaceUri, // Deprecated in LSP 3.16 but needed by typescript-language-server for goToDefinition
+                // Client capabilities - declare what features we support
+                capabilities: {
+                    workspace: {
+                        // Don't claim to support workspace/configuration since we don't implement it
+                        // This prevents servers from requesting config we can't provide
+                        configuration: false,
+                        // Don't claim to support workspace folders changes since we don't handle
+                        // workspace/didChangeWorkspaceFolders notifications
+                        workspaceFolders: false,
+                    },
+                    textDocument: {
+                        synchronization: {
+                            dynamicRegistration: false,
+                            willSave: false,
+                            willSaveWaitUntil: false,
+                            didSave: true,
+                        },
+                        publishDiagnostics: {
+                            relatedInformation: true,
+                            tagSupport: {
+                                valueSet: [1, 2], // Unnecessary (1), Deprecated (2)
+                            },
+                            versionSupport: false,
+                            codeDescriptionSupport: true,
+                            dataSupport: false,
+                        },
+                        hover: {
+                            dynamicRegistration: false,
+                            contentFormat: ['markdown', 'plaintext'],
+                        },
+                        definition: {
+                            dynamicRegistration: false,
+                            linkSupport: true,
+                        },
+                        references: {
+                            dynamicRegistration: false,
+                        },
+                        documentSymbol: {
+                            dynamicRegistration: false,
+                            hierarchicalDocumentSymbolSupport: true,
+                        },
+                        callHierarchy: {
+                            dynamicRegistration: false,
+                        },
+                    },
+                    general: {
+                        positionEncodings: ['utf-16'],
+                    },
+                },
+            };
+            initPromise = client.initialize(initParams);
+            if (config.startupTimeout !== undefined) {
+                await withTimeout(initPromise, config.startupTimeout, `LSP server '${name}' timed out after ${config.startupTimeout}ms during initialization`);
+            }
+            else {
+                await initPromise;
+            }
+            state = 'running';
+            startTime = new Date();
+            crashRecoveryCount = 0;
+            logForDebugging(`LSP server instance started: ${name}`);
+        }
+        catch (error) {
+            // Clean up the spawned child process on timeout/error
+            client.stop().catch(() => { });
+            // Prevent unhandled rejection from abandoned initialize promise
+            initPromise?.catch(() => { });
+            state = 'error';
+            lastError = error;
+            logError(error);
+            throw error;
+        }
+    }
+    /**
+     * Stops the LSP server gracefully.
+     *
+     * If already stopped or stopping, returns immediately.
+     * On failure, sets state to 'error', logs for monitoring, and throws.
+     *
+     * @throws {Error} If server fails to stop
+     */
+    async function stop() {
+        if (state === 'stopped' || state === 'stopping') {
+            return;
+        }
+        try {
+            state = 'stopping';
+            await client.stop();
+            state = 'stopped';
+            logForDebugging(`LSP server instance stopped: ${name}`);
+        }
+        catch (error) {
+            state = 'error';
+            lastError = error;
+            logError(error);
+            throw error;
+        }
+    }
+    /**
+     * Manually restarts the server by stopping and starting it.
+     *
+     * Increments restartCount and enforces maxRestarts limit.
+     * Note: This is NOT automatic - must be called explicitly.
+     *
+     * @throws {Error} If stop or start fails, or if restartCount exceeds config.maxRestarts (default: 3)
+     */
+    async function restart() {
+        try {
+            await stop();
+        }
+        catch (error) {
+            const stopError = new Error(`Failed to stop LSP server '${name}' during restart: ${errorMessage(error)}`);
+            logError(stopError);
+            throw stopError;
+        }
+        restartCount++;
+        const maxRestarts = config.maxRestarts ?? 3;
+        if (restartCount > maxRestarts) {
+            const error = new Error(`Max restart attempts (${maxRestarts}) exceeded for server '${name}'`);
+            logError(error);
+            throw error;
+        }
+        try {
+            await start();
+        }
+        catch (error) {
+            const startError = new Error(`Failed to start LSP server '${name}' during restart (attempt ${restartCount}/${maxRestarts}): ${errorMessage(error)}`);
+            logError(startError);
+            throw startError;
+        }
+    }
+    /**
+     * Checks if the server is healthy and ready to handle requests.
+     *
+     * @returns true if state is 'running' AND the client has completed initialization
+     */
+    function isHealthy() {
+        return state === 'running' && client.isInitialized;
+    }
+    /**
+     * Sends an LSP request to the server with retry logic for transient errors.
+     *
+     * Checks server health before sending and wraps errors with context.
+     * Automatically retries on "content modified" errors (code -32801) which occur
+     * when servers like rust-analyzer are still indexing. This is expected LSP behavior
+     * and clients should retry silently per the LSP specification.
+     *
+     * @param method - LSP method name (e.g., 'textDocument/definition')
+     * @param params - Method-specific parameters
+     * @returns The server's response
+     * @throws {Error} If server is not healthy or request fails after all retries
+     */
+    async function sendRequest(method, params) {
+        if (!isHealthy()) {
+            const error = new Error(`Cannot send request to LSP server '${name}': server is ${state}` +
+                `${lastError ? `, last error: ${lastError.message}` : ''}`);
+            logError(error);
+            throw error;
+        }
+        let lastAttemptError;
+        for (let attempt = 0; attempt <= MAX_RETRIES_FOR_TRANSIENT_ERRORS; attempt++) {
+            try {
+                return await client.sendRequest(method, params);
+            }
+            catch (error) {
+                lastAttemptError = error;
+                // Check if this is a transient "content modified" error that we should retry
+                // This commonly happens with rust-analyzer during initial project indexing.
+                // We use duck typing instead of instanceof because there may be multiple
+                // versions of vscode-jsonrpc in the dependency tree (8.2.0 vs 8.2.1).
+                const errorCode = error.code;
+                const isContentModifiedError = typeof errorCode === 'number' &&
+                    errorCode === LSP_ERROR_CONTENT_MODIFIED;
+                if (isContentModifiedError &&
+                    attempt < MAX_RETRIES_FOR_TRANSIENT_ERRORS) {
+                    const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+                    logForDebugging(`LSP request '${method}' to '${name}' got ContentModified error, ` +
+                        `retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES_FOR_TRANSIENT_ERRORS})…`);
+                    await sleep(delay);
+                    continue;
+                }
+                // Non-retryable error or max retries exceeded
+                break;
+            }
+        }
+        // All retries failed or non-retryable error
+        const requestError = new Error(`LSP request '${method}' failed for server '${name}': ${lastAttemptError?.message ?? 'unknown error'}`);
+        logError(requestError);
+        throw requestError;
+    }
+    /**
+     * Send a notification to the LSP server (fire-and-forget).
+     * Used for file synchronization (didOpen, didChange, didClose).
+     */
+    async function sendNotification(method, params) {
+        if (!isHealthy()) {
+            const error = new Error(`Cannot send notification to LSP server '${name}': server is ${state}`);
+            logError(error);
+            throw error;
+        }
+        try {
+            await client.sendNotification(method, params);
+        }
+        catch (error) {
+            const notificationError = new Error(`LSP notification '${method}' failed for server '${name}': ${errorMessage(error)}`);
+            logError(notificationError);
+            throw notificationError;
+        }
+    }
+    /**
+     * Registers a handler for LSP notifications from the server.
+     *
+     * @param method - LSP notification method (e.g., 'window/logMessage')
+     * @param handler - Callback function to handle the notification
+     */
+    function onNotification(method, handler) {
+        client.onNotification(method, handler);
+    }
+    /**
+     * Registers a handler for LSP requests from the server.
+     *
+     * Some LSP servers send requests TO the client (reverse direction).
+     * This allows registering handlers for such requests.
+     *
+     * @param method - LSP request method (e.g., 'workspace/configuration')
+     * @param handler - Callback function to handle the request and return a response
+     */
+    function onRequest(method, handler) {
+        client.onRequest(method, handler);
+    }
+    // Return public API
+    return {
+        name,
+        config,
+        get state() {
+            return state;
+        },
+        get startTime() {
+            return startTime;
+        },
+        get lastError() {
+            return lastError;
+        },
+        get restartCount() {
+            return restartCount;
+        },
+        start,
+        stop,
+        restart,
+        isHealthy,
+        sendRequest,
+        sendNotification,
+        onNotification,
+        onRequest,
+    };
+}
+/**
+ * Race a promise against a timeout. Cleans up the timer regardless of outcome
+ * to avoid unhandled rejections from orphaned setTimeout callbacks.
+ */
+function withTimeout(promise, ms, message) {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout((rej, msg) => rej(new Error(msg)), ms, reject, message);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timer));
+}

package/src/services/lsp/LSPServerManager.js

@@ -0,0 +1,305 @@
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { getAllLspServers } from './config.js';
+import { createLSPServerInstance, } from './LSPServerInstance.js';
+/**
+ * Creates an LSP server manager instance.
+ *
+ * Manages multiple LSP server instances and routes requests based on file extensions.
+ * Uses factory function pattern with closures for state encapsulation (avoiding classes).
+ *
+ * @returns LSP server manager instance
+ *
+ * @example
+ * const manager = createLSPServerManager()
+ * await manager.initialize()
+ * const result = await manager.sendRequest('/path/to/file.ts', 'textDocument/definition', params)
+ * await manager.shutdown()
+ */
+export function createLSPServerManager() {
+    // Private state managed via closures
+    const servers = new Map();
+    const extensionMap = new Map();
+    // Track which files have been opened on which servers (URI -> server name)
+    const openedFiles = new Map();
+    /**
+     * Initialize the manager by loading all configured LSP servers.
+     *
+     * @throws {Error} If configuration loading fails
+     */
+    async function initialize() {
+        let serverConfigs;
+        try {
+            const result = await getAllLspServers();
+            serverConfigs = result.servers;
+            logForDebugging(`[LSP SERVER MANAGER] getAllLspServers returned ${Object.keys(serverConfigs).length} server(s)`);
+        }
+        catch (error) {
+            const err = error;
+            logError(new Error(`Failed to load LSP server configuration: ${err.message}`));
+            throw error;
+        }
+        // Build extension → server mapping
+        for (const [serverName, config] of Object.entries(serverConfigs)) {
+            try {
+                // Validate config before using it
+                if (!config.command) {
+                    throw new Error(`Server ${serverName} missing required 'command' field`);
+                }
+                if (!config.extensionToLanguage ||
+                    Object.keys(config.extensionToLanguage).length === 0) {
+                    throw new Error(`Server ${serverName} missing required 'extensionToLanguage' field`);
+                }
+                // Map file extensions to this server (derive from extensionToLanguage)
+                const fileExtensions = Object.keys(config.extensionToLanguage);
+                for (const ext of fileExtensions) {
+                    const normalized = ext.toLowerCase();
+                    if (!extensionMap.has(normalized)) {
+                        extensionMap.set(normalized, []);
+                    }
+                    const serverList = extensionMap.get(normalized);
+                    if (serverList) {
+                        serverList.push(serverName);
+                    }
+                }
+                // Create server instance
+                const instance = createLSPServerInstance(serverName, config);
+                servers.set(serverName, instance);
+                // Register handler for workspace/configuration requests from the server
+                // Some servers (like TypeScript) send these even when we say we don't support them
+                instance.onRequest('workspace/configuration', (params) => {
+                    logForDebugging(`LSP: Received workspace/configuration request from ${serverName}`);
+                    // Return empty/null config for each requested item
+                    // This satisfies the protocol without providing actual configuration
+                    return params.items.map(() => null);
+                });
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`Failed to initialize LSP server ${serverName}: ${err.message}`));
+                // Continue with other servers - don't fail entire initialization
+            }
+        }
+        logForDebugging(`LSP manager initialized with ${servers.size} servers`);
+    }
+    /**
+     * Shutdown all running servers and clear state.
+     * Only servers in 'running' state are explicitly stopped;
+     * servers in other states are cleared without shutdown.
+     *
+     * @throws {Error} If one or more servers fail to stop
+     */
+    async function shutdown() {
+        const toStop = Array.from(servers.entries()).filter(([, s]) => s.state === 'running' || s.state === 'error');
+        const results = await Promise.allSettled(toStop.map(([, server]) => server.stop()));
+        servers.clear();
+        extensionMap.clear();
+        openedFiles.clear();
+        const errors = results
+            .map((r, i) => r.status === 'rejected'
+            ? `${toStop[i][0]}: ${errorMessage(r.reason)}`
+            : null)
+            .filter((e) => e !== null);
+        if (errors.length > 0) {
+            const err = new Error(`Failed to stop ${errors.length} LSP server(s): ${errors.join('; ')}`);
+            logError(err);
+            throw err;
+        }
+    }
+    /**
+     * Get the LSP server instance for a given file path.
+     * If multiple servers handle the same extension, returns the first registered server.
+     * Returns undefined if no server handles this file type.
+     */
+    function getServerForFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const serverNames = extensionMap.get(ext);
+        if (!serverNames || serverNames.length === 0) {
+            return undefined;
+        }
+        // Use first server (can add priority later)
+        const serverName = serverNames[0];
+        if (!serverName) {
+            return undefined;
+        }
+        return servers.get(serverName);
+    }
+    /**
+     * Ensure the appropriate LSP server is started for the given file.
+     * Returns undefined if no server handles this file type.
+     *
+     * @throws {Error} If server fails to start
+     */
+    async function ensureServerStarted(filePath) {
+        const server = getServerForFile(filePath);
+        if (!server)
+            return undefined;
+        if (server.state === 'stopped' || server.state === 'error') {
+            try {
+                await server.start();
+            }
+            catch (error) {
+                const err = error;
+                logError(new Error(`Failed to start LSP server for file ${filePath}: ${err.message}`));
+                throw error;
+            }
+        }
+        return server;
+    }
+    /**
+     * Send a request to the appropriate LSP server for the given file.
+     * Returns undefined if no server handles this file type.
+     *
+     * @throws {Error} If server fails to start or request fails
+     */
+    async function sendRequest(filePath, method, params) {
+        const server = await ensureServerStarted(filePath);
+        if (!server)
+            return undefined;
+        try {
+            return await server.sendRequest(method, params);
+        }
+        catch (error) {
+            const err = error;
+            logError(new Error(`LSP request failed for file ${filePath}, method '${method}': ${err.message}`));
+            throw error;
+        }
+    }
+    // Return public interface
+    function getAllServers() {
+        return servers;
+    }
+    async function openFile(filePath, content) {
+        const server = await ensureServerStarted(filePath);
+        if (!server)
+            return;
+        const fileUri = pathToFileURL(path.resolve(filePath)).href;
+        // Skip if already opened on this server
+        if (openedFiles.get(fileUri) === server.name) {
+            logForDebugging(`LSP: File already open, skipping didOpen for ${filePath}`);
+            return;
+        }
+        // Get language ID from server's extensionToLanguage mapping
+        const ext = path.extname(filePath).toLowerCase();
+        const languageId = server.config.extensionToLanguage[ext] || 'plaintext';
+        try {
+            await server.sendNotification('textDocument/didOpen', {
+                textDocument: {
+                    uri: fileUri,
+                    languageId,
+                    version: 1,
+                    text: content,
+                },
+            });
+            // Track that this file is now open on this server
+            openedFiles.set(fileUri, server.name);
+            logForDebugging(`LSP: Sent didOpen for ${filePath} (languageId: ${languageId})`);
+        }
+        catch (error) {
+            const err = new Error(`Failed to sync file open ${filePath}: ${errorMessage(error)}`);
+            logError(err);
+            // Re-throw to propagate error to caller
+            throw err;
+        }
+    }
+    async function changeFile(filePath, content) {
+        const server = getServerForFile(filePath);
+        if (!server || server.state !== 'running') {
+            return openFile(filePath, content);
+        }
+        const fileUri = pathToFileURL(path.resolve(filePath)).href;
+        // If file hasn't been opened on this server yet, open it first
+        // LSP servers require didOpen before didChange
+        if (openedFiles.get(fileUri) !== server.name) {
+            return openFile(filePath, content);
+        }
+        try {
+            await server.sendNotification('textDocument/didChange', {
+                textDocument: {
+                    uri: fileUri,
+                    version: 1,
+                },
+                contentChanges: [{ text: content }],
+            });
+            logForDebugging(`LSP: Sent didChange for ${filePath}`);
+        }
+        catch (error) {
+            const err = new Error(`Failed to sync file change ${filePath}: ${errorMessage(error)}`);
+            logError(err);
+            // Re-throw to propagate error to caller
+            throw err;
+        }
+    }
+    /**
+     * Save a file in LSP servers (sends didSave notification)
+     * Called after file is written to disk to trigger diagnostics
+     */
+    async function saveFile(filePath) {
+        const server = getServerForFile(filePath);
+        if (!server || server.state !== 'running')
+            return;
+        try {
+            await server.sendNotification('textDocument/didSave', {
+                textDocument: {
+                    uri: pathToFileURL(path.resolve(filePath)).href,
+                },
+            });
+            logForDebugging(`LSP: Sent didSave for ${filePath}`);
+        }
+        catch (error) {
+            const err = new Error(`Failed to sync file save ${filePath}: ${errorMessage(error)}`);
+            logError(err);
+            // Re-throw to propagate error to caller
+            throw err;
+        }
+    }
+    /**
+     * Close a file in LSP servers (sends didClose notification)
+     *
+     * NOTE: Currently available but not yet integrated with compact flow.
+     * TODO: Integrate with compact - call closeFile() when compact removes files from context
+     * This will notify LSP servers that files are no longer in active use.
+     */
+    async function closeFile(filePath) {
+        const server = getServerForFile(filePath);
+        if (!server || server.state !== 'running')
+            return;
+        const fileUri = pathToFileURL(path.resolve(filePath)).href;
+        try {
+            await server.sendNotification('textDocument/didClose', {
+                textDocument: {
+                    uri: fileUri,
+                },
+            });
+            // Remove from tracking so file can be reopened later
+            openedFiles.delete(fileUri);
+            logForDebugging(`LSP: Sent didClose for ${filePath}`);
+        }
+        catch (error) {
+            const err = new Error(`Failed to sync file close ${filePath}: ${errorMessage(error)}`);
+            logError(err);
+            // Re-throw to propagate error to caller
+            throw err;
+        }
+    }
+    function isFileOpen(filePath) {
+        const fileUri = pathToFileURL(path.resolve(filePath)).href;
+        return openedFiles.has(fileUri);
+    }
+    return {
+        initialize,
+        shutdown,
+        getServerForFile,
+        ensureServerStarted,
+        sendRequest,
+        getAllServers,
+        openFile,
+        changeFile,
+        saveFile,
+        closeFile,
+        isFileOpen,
+    };
+}