@stanco323/oh-my-claude-code 4.10.3

package/dist/tools/lsp/client.js

@@ -0,0 +1,906 @@
+/**
+ * LSP Client Implementation
+ *
+ * Manages connections to language servers using JSON-RPC 2.0 over stdio.
+ * Handles server lifecycle, message buffering, and request/response matching.
+ */
+import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname, parse, join } from 'path';
+import { pathToFileURL } from 'url';
+import { resolveDevContainerContext, hostUriToContainerUri, containerUriToHostUri } from './devcontainer.js';
+import { getServerForFile, commandExists } from './servers.js';
+/** Default timeout (ms) for LSP requests. Override with OMC_LSP_TIMEOUT_MS env var. */
+export const DEFAULT_LSP_REQUEST_TIMEOUT_MS = (() => {
+    return readPositiveIntEnv('OMC_LSP_TIMEOUT_MS', 15_000);
+})();
+export function getLspRequestTimeout(serverConfig, method, baseTimeout = DEFAULT_LSP_REQUEST_TIMEOUT_MS) {
+    if (method === 'initialize' && serverConfig.initializeTimeoutMs) {
+        return Math.max(baseTimeout, serverConfig.initializeTimeoutMs);
+    }
+    return baseTimeout;
+}
+function readPositiveIntEnv(name, fallback) {
+    const env = process.env[name];
+    if (!env) {
+        return fallback;
+    }
+    const parsed = parseInt(env, 10);
+    return !isNaN(parsed) && parsed > 0 ? parsed : fallback;
+}
+/** Convert a file path to a valid file:// URI (cross-platform) */
+function fileUri(filePath) {
+    return pathToFileURL(resolve(filePath)).href;
+}
+/**
+ * LSP Client class
+ */
+export class LspClient {
+    static MAX_BUFFER_SIZE = 50 * 1024 * 1024; // 50MB
+    process = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = Buffer.alloc(0);
+    openDocuments = new Set();
+    diagnostics = new Map();
+    diagnosticWaiters = new Map();
+    workspaceRoot;
+    serverConfig;
+    devContainerContext;
+    initialized = false;
+    _serverCapabilities = null;
+    _supportsPullDiagnostics = false;
+    constructor(workspaceRoot, serverConfig, devContainerContext = null) {
+        this.workspaceRoot = resolve(workspaceRoot);
+        this.serverConfig = serverConfig;
+        this.devContainerContext = devContainerContext;
+    }
+    /**
+     * Start the LSP server and initialize the connection
+     */
+    async connect() {
+        if (this.process) {
+            return; // Already connected
+        }
+        const spawnCommand = this.devContainerContext ? 'docker' : this.serverConfig.command;
+        if (!commandExists(spawnCommand)) {
+            throw new Error(this.devContainerContext
+                ? `Docker CLI not found. Required to start '${this.serverConfig.command}' inside container ${this.devContainerContext.containerId}.`
+                : `Language server '${this.serverConfig.command}' not found.\nInstall with: ${this.serverConfig.installHint}`);
+        }
+        return new Promise((resolve, reject) => {
+            // On Windows, npm-installed binaries are .cmd scripts that require
+            // shell execution. Without this, spawn() fails with ENOENT. (#569)
+            // Safe: server commands come from a hardcoded registry (servers.ts),
+            // not user input, so shell metacharacter injection is not a concern.
+            const command = this.devContainerContext ? 'docker' : this.serverConfig.command;
+            const args = this.devContainerContext
+                ? ['exec', '-i', '-w', this.devContainerContext.containerWorkspaceRoot, this.devContainerContext.containerId, this.serverConfig.command, ...this.serverConfig.args]
+                : this.serverConfig.args;
+            this.process = spawn(command, args, {
+                cwd: this.workspaceRoot,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                shell: !this.devContainerContext && process.platform === 'win32'
+            });
+            this.process.stdout?.on('data', (data) => {
+                this.handleData(data);
+            });
+            this.process.stderr?.on('data', (data) => {
+                // Log stderr for debugging but don't fail
+                console.error(`LSP stderr: ${data.toString()}`);
+            });
+            this.process.on('error', (error) => {
+                reject(new Error(`Failed to start LSP server: ${error.message}`));
+            });
+            this.process.on('exit', (code) => {
+                this.process = null;
+                this.initialized = false;
+                if (code !== 0) {
+                    console.error(`LSP server exited with code ${code}`);
+                }
+                // Reject all pending requests to avoid unresolved promises
+                this.rejectPendingRequests(new Error(`LSP server exited (code ${code})`));
+            });
+            // Send initialize request
+            this.initialize()
+                .then(() => {
+                this.initialized = true;
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    /**
+     * Synchronously kill the LSP server process.
+     * Used in process exit handlers where async operations are not possible.
+     */
+    forceKill() {
+        if (this.process) {
+            try {
+                this.process.kill('SIGKILL');
+            }
+            catch {
+                // Ignore errors during kill
+            }
+            this.process = null;
+            this.initialized = false;
+            // Wake diagnostic waiters to prevent resource leaks
+            for (const waiters of this.diagnosticWaiters.values()) {
+                for (const wake of waiters)
+                    wake();
+            }
+            this.diagnosticWaiters.clear();
+        }
+    }
+    /**
+     * Disconnect from the LSP server
+     */
+    async disconnect() {
+        if (!this.process)
+            return;
+        try {
+            // Short timeout for graceful shutdown — don't block forever
+            await this.request('shutdown', null, 3000);
+            this.notify('exit', null);
+        }
+        catch {
+            // Ignore errors during shutdown
+        }
+        finally {
+            // Always kill the process regardless of shutdown success
+            if (this.process) {
+                this.process.kill();
+                this.process = null;
+            }
+            this.initialized = false;
+            this.rejectPendingRequests(new Error('Client disconnected'));
+            this.openDocuments.clear();
+            this.diagnostics.clear();
+            // Wake all diagnostic waiters so their setTimeout closures can be GC'd
+            for (const waiters of this.diagnosticWaiters.values()) {
+                for (const wake of waiters)
+                    wake();
+            }
+            this.diagnosticWaiters.clear();
+        }
+    }
+    /**
+     * Reject all pending requests with the given error.
+     * Called on process exit to avoid dangling unresolved promises.
+     */
+    rejectPendingRequests(error) {
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            clearTimeout(pending.timeout);
+            pending.reject(error);
+            this.pendingRequests.delete(id);
+        }
+    }
+    /**
+     * Handle incoming data from the server
+     */
+    handleData(data) {
+        this.buffer = Buffer.concat([this.buffer, data]);
+        // Prevent unbounded buffer growth from misbehaving LSP server
+        if (this.buffer.length > LspClient.MAX_BUFFER_SIZE) {
+            console.error('[LSP] Response buffer exceeded 50MB limit, resetting');
+            this.buffer = Buffer.alloc(0);
+            this.rejectPendingRequests(new Error('LSP response buffer overflow'));
+            return;
+        }
+        while (true) {
+            // Look for Content-Length header
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.subarray(0, headerEnd).toString();
+            const contentLengthMatch = header.match(/Content-Length: (\d+)/i);
+            if (!contentLengthMatch) {
+                // Invalid header, try to recover
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(contentLengthMatch[1], 10);
+            const messageStart = headerEnd + 4;
+            const messageEnd = messageStart + contentLength;
+            if (this.buffer.length < messageEnd) {
+                break; // Not enough data yet
+            }
+            const messageJson = this.buffer.subarray(messageStart, messageEnd).toString();
+            this.buffer = this.buffer.subarray(messageEnd);
+            try {
+                const message = JSON.parse(messageJson);
+                this.handleMessage(message);
+            }
+            catch {
+                // Invalid JSON, skip
+            }
+        }
+    }
+    /**
+     * Handle a parsed JSON-RPC message
+     */
+    handleMessage(message) {
+        if ('id' in message && message.id !== undefined) {
+            // Response to a request
+            const pending = this.pendingRequests.get(message.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingRequests.delete(message.id);
+                if (message.error) {
+                    pending.reject(new Error(message.error.message));
+                }
+                else {
+                    pending.resolve(message.result);
+                }
+            }
+        }
+        else if ('method' in message) {
+            // Notification from server
+            this.handleNotification(message);
+        }
+    }
+    /**
+     * Handle server notifications
+     */
+    handleNotification(notification) {
+        if (notification.method === 'textDocument/publishDiagnostics') {
+            const params = this.translateIncomingPayload(notification.params);
+            this.diagnostics.set(params.uri, params.diagnostics);
+            // Wake any waiters registered via waitForDiagnostics()
+            const waiters = this.diagnosticWaiters.get(params.uri);
+            if (waiters && waiters.length > 0) {
+                this.diagnosticWaiters.delete(params.uri);
+                for (const wake of waiters)
+                    wake();
+            }
+        }
+        // Handle other notifications as needed
+    }
+    /**
+     * Send a request to the server
+     */
+    async request(method, params, timeout) {
+        if (!this.process?.stdin) {
+            throw new Error('LSP server not connected');
+        }
+        const effectiveTimeout = timeout ?? getLspRequestTimeout(this.serverConfig, method);
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params
+        };
+        const content = JSON.stringify(request);
+        const message = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n${content}`;
+        return new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`LSP request '${method}' timed out after ${effectiveTimeout}ms`));
+            }, effectiveTimeout);
+            this.pendingRequests.set(id, {
+                resolve: resolve,
+                reject,
+                timeout: timeoutHandle
+            });
+            this.process?.stdin?.write(message);
+        });
+    }
+    /**
+     * Send a notification to the server (no response expected)
+     */
+    notify(method, params) {
+        if (!this.process?.stdin)
+            return;
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        const content = JSON.stringify(notification);
+        const message = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n${content}`;
+        this.process.stdin.write(message);
+    }
+    /**
+     * Initialize the LSP connection
+     */
+    async initialize() {
+        const initResult = await this.request('initialize', {
+            processId: process.pid,
+            rootUri: this.getWorkspaceRootUri(),
+            rootPath: this.getServerWorkspaceRoot(),
+            capabilities: {
+                textDocument: {
+                    hover: { contentFormat: ['markdown', 'plaintext'] },
+                    definition: { linkSupport: true },
+                    references: {},
+                    documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+                    codeAction: { codeActionLiteralSupport: { codeActionKind: { valueSet: [] } } },
+                    rename: { prepareSupport: true },
+                    publishDiagnostics: {
+                        relatedInformation: true,
+                        tagSupport: { valueSet: [1, 2] }
+                    }
+                },
+                workspace: {
+                    symbol: {},
+                    workspaceFolders: true
+                }
+            },
+            initializationOptions: this.serverConfig.initializationOptions || {}
+        }, getLspRequestTimeout(this.serverConfig, 'initialize'));
+        this._serverCapabilities = initResult?.capabilities ?? null;
+        this._supportsPullDiagnostics = !!this._serverCapabilities?.diagnosticProvider;
+        this.notify('initialized', {});
+    }
+    /**
+     * Open a document for editing
+     */
+    async openDocument(filePath) {
+        const hostUri = fileUri(filePath);
+        const uri = this.toServerUri(hostUri);
+        if (this.openDocuments.has(hostUri))
+            return;
+        if (!existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const content = readFileSync(filePath, 'utf-8');
+        const languageId = this.getLanguageId(filePath);
+        this.notify('textDocument/didOpen', {
+            textDocument: {
+                uri,
+                languageId,
+                version: 1,
+                text: content
+            }
+        });
+        this.openDocuments.add(hostUri);
+        // Wait a bit for the server to process the document
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    /**
+     * Close a document
+     */
+    closeDocument(filePath) {
+        const hostUri = fileUri(filePath);
+        const uri = this.toServerUri(hostUri);
+        if (!this.openDocuments.has(hostUri))
+            return;
+        this.notify('textDocument/didClose', {
+            textDocument: { uri }
+        });
+        this.openDocuments.delete(hostUri);
+    }
+    /**
+     * Get the language ID for a file
+     */
+    getLanguageId(filePath) {
+        // parse().ext correctly handles dotfiles: parse('.eslintrc').ext === ''
+        // whereas split('.').pop() returns 'eslintrc' for dotfiles (incorrect)
+        const ext = parse(filePath).ext.slice(1).toLowerCase();
+        const langMap = {
+            'ts': 'typescript',
+            'tsx': 'typescriptreact',
+            'js': 'javascript',
+            'jsx': 'javascriptreact',
+            'mts': 'typescript',
+            'cts': 'typescript',
+            'mjs': 'javascript',
+            'cjs': 'javascript',
+            'py': 'python',
+            'rs': 'rust',
+            'go': 'go',
+            'c': 'c',
+            'h': 'c',
+            'cpp': 'cpp',
+            'cc': 'cpp',
+            'hpp': 'cpp',
+            'java': 'java',
+            'json': 'json',
+            'html': 'html',
+            'css': 'css',
+            'scss': 'scss',
+            'yaml': 'yaml',
+            'yml': 'yaml',
+            'php': 'php',
+            'phtml': 'php',
+            'rb': 'ruby',
+            'rake': 'ruby',
+            'gemspec': 'ruby',
+            'erb': 'ruby',
+            'lua': 'lua',
+            'kt': 'kotlin',
+            'kts': 'kotlin',
+            'ex': 'elixir',
+            'exs': 'elixir',
+            'heex': 'elixir',
+            'eex': 'elixir',
+            'cs': 'csharp'
+        };
+        return langMap[ext] || ext;
+    }
+    /**
+     * Convert file path to URI and ensure document is open
+     */
+    async prepareDocument(filePath) {
+        await this.openDocument(filePath);
+        return this.toServerUri(fileUri(filePath));
+    }
+    // LSP Request Methods
+    /**
+     * Get hover information at a position
+     */
+    async hover(filePath, line, character) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/hover', {
+            textDocument: { uri },
+            position: { line, character }
+        });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Go to definition
+     */
+    async definition(filePath, line, character) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/definition', {
+            textDocument: { uri },
+            position: { line, character }
+        });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Find all references
+     */
+    async references(filePath, line, character, includeDeclaration = true) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/references', {
+            textDocument: { uri },
+            position: { line, character },
+            context: { includeDeclaration }
+        });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Get document symbols
+     */
+    async documentSymbols(filePath) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/documentSymbol', {
+            textDocument: { uri }
+        });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Search workspace symbols
+     */
+    async workspaceSymbols(query) {
+        const result = await this.request('workspace/symbol', { query });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Get diagnostics for a file
+     */
+    getDiagnostics(filePath) {
+        const uri = fileUri(filePath);
+        return this.diagnostics.get(uri) || [];
+    }
+    /**
+     * Whether the server supports LSP 3.17 pull diagnostics (textDocument/diagnostic).
+     */
+    get supportsPullDiagnostics() {
+        return this._supportsPullDiagnostics;
+    }
+    /**
+     * Request diagnostics via the LSP 3.17 pull model (textDocument/diagnostic).
+     * Only call when supportsPullDiagnostics is true.
+     */
+    async pullDiagnostics(filePath) {
+        const uri = this.toServerUri(fileUri(filePath));
+        const result = await this.request('textDocument/diagnostic', { textDocument: { uri } });
+        return ((result?.items) || []).map((d) => ({
+            range: d.range,
+            message: d.message,
+            severity: d.severity,
+            source: d.source,
+            code: d.code,
+        }));
+    }
+    /**
+     * Wait for the server to publish diagnostics for a file.
+     * Resolves as soon as textDocument/publishDiagnostics fires for the URI,
+     * or after `timeoutMs` milliseconds (whichever comes first).
+     * This replaces fixed-delay sleeps with a notification-driven approach.
+     */
+    waitForDiagnostics(filePath, timeoutMs = 2000) {
+        const uri = fileUri(filePath);
+        // If diagnostics are already present, resolve immediately.
+        if (this.diagnostics.has(uri)) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            const timer = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    this.diagnosticWaiters.delete(uri);
+                    resolve();
+                }
+            }, timeoutMs);
+            // Store the resolver so handleNotification can wake it up.
+            const existing = this.diagnosticWaiters.get(uri) || [];
+            existing.push(() => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timer);
+                    resolve();
+                }
+            });
+            this.diagnosticWaiters.set(uri, existing);
+        });
+    }
+    /**
+     * Prepare rename (check if rename is valid)
+     */
+    async prepareRename(filePath, line, character) {
+        const uri = await this.prepareDocument(filePath);
+        try {
+            const result = await this.request('textDocument/prepareRename', {
+                textDocument: { uri },
+                position: { line, character }
+            });
+            if (!result)
+                return null;
+            return 'range' in result ? result.range : result;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Rename a symbol
+     */
+    async rename(filePath, line, character, newName) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/rename', {
+            textDocument: { uri },
+            position: { line, character },
+            newName
+        });
+        return this.translateIncomingPayload(result);
+    }
+    /**
+     * Get code actions
+     */
+    async codeActions(filePath, range, diagnostics = []) {
+        const uri = await this.prepareDocument(filePath);
+        const result = await this.request('textDocument/codeAction', {
+            textDocument: { uri },
+            range,
+            context: { diagnostics }
+        });
+        return this.translateIncomingPayload(result);
+    }
+    getServerWorkspaceRoot() {
+        return this.devContainerContext?.containerWorkspaceRoot ?? this.workspaceRoot;
+    }
+    getWorkspaceRootUri() {
+        return this.toServerUri(pathToFileURL(this.workspaceRoot).href);
+    }
+    toServerUri(uri) {
+        return hostUriToContainerUri(uri, this.devContainerContext);
+    }
+    toHostUri(uri) {
+        return containerUriToHostUri(uri, this.devContainerContext);
+    }
+    translateIncomingPayload(value) {
+        if (!this.devContainerContext || value == null) {
+            return value;
+        }
+        return this.translateIncomingValue(value);
+    }
+    translateIncomingValue(value) {
+        if (Array.isArray(value)) {
+            return value.map(item => this.translateIncomingValue(item));
+        }
+        if (!value || typeof value !== 'object') {
+            return value;
+        }
+        const record = value;
+        const translatedEntries = Object.entries(record).map(([key, entryValue]) => {
+            if ((key === 'uri' || key === 'targetUri' || key === 'newUri' || key === 'oldUri') && typeof entryValue === 'string') {
+                return [key, this.toHostUri(entryValue)];
+            }
+            if (key === 'changes' && entryValue && typeof entryValue === 'object' && !Array.isArray(entryValue)) {
+                const translatedChanges = Object.fromEntries(Object.entries(entryValue).map(([uri, changeValue]) => [
+                    this.toHostUri(uri),
+                    this.translateIncomingValue(changeValue)
+                ]));
+                return [key, translatedChanges];
+            }
+            return [key, this.translateIncomingValue(entryValue)];
+        });
+        return Object.fromEntries(translatedEntries);
+    }
+}
+/** Idle timeout: disconnect LSP clients unused for 5 minutes */
+export const IDLE_TIMEOUT_MS = readPositiveIntEnv('OMC_LSP_IDLE_TIMEOUT_MS', 5 * 60 * 1000);
+/** Check for idle clients every 60 seconds */
+export const IDLE_CHECK_INTERVAL_MS = readPositiveIntEnv('OMC_LSP_IDLE_CHECK_INTERVAL_MS', 60 * 1000);
+/**
+ * Client manager - maintains a pool of LSP clients per workspace/server
+ * with idle eviction to free resources and in-flight request protection.
+ */
+export class LspClientManager {
+    clients = new Map();
+    lastUsed = new Map();
+    inFlightCount = new Map();
+    idleDeadlines = new Map();
+    idleTimer = null;
+    constructor() {
+        this.startIdleCheck();
+        this.registerCleanupHandlers();
+    }
+    /**
+     * Register process exit/signal handlers to kill all spawned LSP server processes.
+     * Prevents orphaned language server processes (e.g. kotlin-language-server)
+     * when the MCP bridge process exits or a claude session ends.
+     */
+    registerCleanupHandlers() {
+        const forceKillAll = () => {
+            if (this.idleTimer) {
+                clearInterval(this.idleTimer);
+                this.idleTimer = null;
+            }
+            for (const timer of this.idleDeadlines.values()) {
+                clearTimeout(timer);
+            }
+            this.idleDeadlines.clear();
+            for (const client of this.clients.values()) {
+                try {
+                    client.forceKill();
+                }
+                catch {
+                    // Ignore errors during cleanup
+                }
+            }
+            this.clients.clear();
+            this.lastUsed.clear();
+            this.inFlightCount.clear();
+        };
+        // 'exit' handler must be synchronous — forceKill() is sync
+        process.on('exit', forceKillAll);
+        // For signals, force-kill LSP servers but do NOT call process.exit()
+        // to allow other signal handlers (e.g., Python bridge cleanup) to run
+        for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+            process.on(sig, forceKillAll);
+        }
+    }
+    /**
+     * Get or create a client for a file
+     */
+    async getClientForFile(filePath) {
+        const serverConfig = getServerForFile(filePath);
+        if (!serverConfig) {
+            return null;
+        }
+        // Find workspace root
+        const workspaceRoot = this.findWorkspaceRoot(filePath);
+        const devContainerContext = resolveDevContainerContext(workspaceRoot);
+        const key = `${workspaceRoot}:${serverConfig.command}:${devContainerContext?.containerId ?? 'host'}`;
+        let client = this.clients.get(key);
+        if (!client) {
+            client = new LspClient(workspaceRoot, serverConfig, devContainerContext);
+            try {
+                await client.connect();
+                this.clients.set(key, client);
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        this.touchClient(key);
+        return client;
+    }
+    /**
+     * Run a function with in-flight tracking for the client serving filePath.
+     * While the function is running, the client is protected from idle eviction.
+     * The lastUsed timestamp is refreshed on both entry and exit.
+     */
+    async runWithClientLease(filePath, fn) {
+        const serverConfig = getServerForFile(filePath);
+        if (!serverConfig) {
+            throw new Error(`No language server available for: ${filePath}`);
+        }
+        const workspaceRoot = this.findWorkspaceRoot(filePath);
+        const devContainerContext = resolveDevContainerContext(workspaceRoot);
+        const key = `${workspaceRoot}:${serverConfig.command}:${devContainerContext?.containerId ?? 'host'}`;
+        let client = this.clients.get(key);
+        if (!client) {
+            client = new LspClient(workspaceRoot, serverConfig, devContainerContext);
+            try {
+                await client.connect();
+                this.clients.set(key, client);
+            }
+            catch (error) {
+                throw error;
+            }
+        }
+        // Touch timestamp and increment in-flight counter
+        this.touchClient(key);
+        this.inFlightCount.set(key, (this.inFlightCount.get(key) || 0) + 1);
+        try {
+            return await fn(client);
+        }
+        finally {
+            // Decrement in-flight counter and refresh timestamp
+            const count = (this.inFlightCount.get(key) || 1) - 1;
+            if (count <= 0) {
+                this.inFlightCount.delete(key);
+            }
+            else {
+                this.inFlightCount.set(key, count);
+            }
+            this.touchClient(key);
+        }
+    }
+    touchClient(key) {
+        this.lastUsed.set(key, Date.now());
+        this.scheduleIdleDeadline(key);
+    }
+    scheduleIdleDeadline(key) {
+        this.clearIdleDeadline(key);
+        const timer = setTimeout(() => {
+            this.idleDeadlines.delete(key);
+            this.evictClientIfIdle(key);
+        }, IDLE_TIMEOUT_MS);
+        if (typeof timer === 'object' && 'unref' in timer) {
+            timer.unref();
+        }
+        this.idleDeadlines.set(key, timer);
+    }
+    clearIdleDeadline(key) {
+        const timer = this.idleDeadlines.get(key);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.idleDeadlines.delete(key);
+    }
+    /**
+     * Find the workspace root for a file
+     */
+    findWorkspaceRoot(filePath) {
+        let dir = dirname(resolve(filePath));
+        const markers = [
+            'build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts',
+            'pom.xml', 'package.json', 'tsconfig.json', 'pyproject.toml', 'Cargo.toml',
+            'go.mod', '.git'
+        ];
+        // Cross-platform root detection
+        while (true) {
+            const parsed = parse(dir);
+            // On Windows: C:\ has root === dir, On Unix: / has root === dir
+            if (parsed.root === dir) {
+                break;
+            }
+            for (const marker of markers) {
+                const markerPath = join(dir, marker);
+                if (existsSync(markerPath)) {
+                    return dir;
+                }
+            }
+            dir = dirname(dir);
+        }
+        return dirname(resolve(filePath));
+    }
+    /**
+     * Start periodic idle check
+     */
+    startIdleCheck() {
+        if (this.idleTimer)
+            return;
+        this.idleTimer = setInterval(() => {
+            this.evictIdleClients();
+        }, IDLE_CHECK_INTERVAL_MS);
+        // Allow the process to exit even if the timer is running
+        if (this.idleTimer && typeof this.idleTimer === 'object' && 'unref' in this.idleTimer) {
+            this.idleTimer.unref();
+        }
+    }
+    /**
+     * Evict clients that haven't been used within IDLE_TIMEOUT_MS.
+     * Clients with in-flight requests are never evicted.
+     */
+    evictIdleClients() {
+        for (const key of this.lastUsed.keys()) {
+            this.evictClientIfIdle(key);
+        }
+    }
+    evictClientIfIdle(key) {
+        const lastUsedTime = this.lastUsed.get(key);
+        if (lastUsedTime === undefined) {
+            this.clearIdleDeadline(key);
+            return;
+        }
+        const idleFor = Date.now() - lastUsedTime;
+        if (idleFor <= IDLE_TIMEOUT_MS) {
+            const hasDeadline = this.idleDeadlines.has(key);
+            if (!hasDeadline) {
+                this.scheduleIdleDeadline(key);
+            }
+            return;
+        }
+        // Skip eviction if there are in-flight requests
+        if ((this.inFlightCount.get(key) || 0) > 0) {
+            this.scheduleIdleDeadline(key);
+            return;
+        }
+        const client = this.clients.get(key);
+        this.clearIdleDeadline(key);
+        this.clients.delete(key);
+        this.lastUsed.delete(key);
+        this.inFlightCount.delete(key);
+        if (client) {
+            client.disconnect().catch(() => {
+                // Ignore disconnect errors during eviction
+            });
+        }
+    }
+    /**
+     * Disconnect all clients and stop idle checking.
+     * Uses Promise.allSettled so one failing disconnect doesn't block others.
+     * Maps are always cleared regardless of individual disconnect failures.
+     */
+    async disconnectAll() {
+        if (this.idleTimer) {
+            clearInterval(this.idleTimer);
+            this.idleTimer = null;
+        }
+        for (const timer of this.idleDeadlines.values()) {
+            clearTimeout(timer);
+        }
+        this.idleDeadlines.clear();
+        const entries = Array.from(this.clients.entries());
+        const results = await Promise.allSettled(entries.map(([, client]) => client.disconnect()));
+        // Log any per-client failures at warn level
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === 'rejected') {
+                const key = entries[i][0];
+                console.warn(`LSP disconnectAll: failed to disconnect client "${key}": ${result.reason}`);
+            }
+        }
+        // Always clear maps regardless of individual failures
+        this.clients.clear();
+        this.lastUsed.clear();
+        this.inFlightCount.clear();
+    }
+    /** Expose in-flight count for testing */
+    getInFlightCount(key) {
+        return this.inFlightCount.get(key) || 0;
+    }
+    /** Expose client count for testing */
+    get clientCount() {
+        return this.clients.size;
+    }
+    /** Trigger idle eviction manually (exposed for testing) */
+    triggerEviction() {
+        this.evictIdleClients();
+    }
+}
+const LSP_CLIENT_MANAGER_KEY = '__omcLspClientManager';
+// Export a process-global singleton instance. This protects against duplicate
+// manager instances if the module is loaded more than once in the same process
+// (for example after module resets in tests or bundle indirection).
+const globalWithLspClientManager = globalThis;
+export const lspClientManager = globalWithLspClientManager[LSP_CLIENT_MANAGER_KEY]
+    ?? (globalWithLspClientManager[LSP_CLIENT_MANAGER_KEY] = new LspClientManager());
+/**
+ * Disconnect all LSP clients and free resources.
+ * Exported for use in session-end hooks.
+ */
+export async function disconnectAll() {
+    return lspClientManager.disconnectAll();
+}
+//# sourceMappingURL=client.js.map