@ashx-j/lunr 0.1.0

package/dist/builtin-extensions/pi-lsp-extension/src/lsp-manager.js

@@ -0,0 +1,633 @@
+// @ts-nocheck
+/**
+ * LSP Manager — manages multiple LSP server instances, one per language.
+ *
+ * Lazily starts servers on first use. Auto-detects language from file extension.
+ * Uses a WorkspaceProvider for workspace detection, multi-root folders, and daemon state.
+ */
+import { resolve, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { spawn as spawnChild } from "node:child_process";
+import { LspClient } from "./lsp-client.js";
+import { DefaultWorkspaceProvider } from "./workspace-provider.js";
+import { getLanguageIdFromPath } from "./shared/language-map.js";
+import { DAEMON_SOCKET_READY_DELAY_MS, DAEMON_RETRY_INTERVAL_MS, DAEMON_MAX_RETRIES } from "./shared/timing.js";
+/** Default server configurations for common languages */
+const DEFAULT_SERVERS = {
+    typescript: { command: "typescript-language-server", args: ["--stdio"] },
+    javascript: { command: "typescript-language-server", args: ["--stdio"] },
+    typescriptreact: { command: "typescript-language-server", args: ["--stdio"] },
+    javascriptreact: { command: "typescript-language-server", args: ["--stdio"] },
+    rust: { command: "rust-analyzer", args: [] },
+    python: { command: "pyright-langserver", args: ["--stdio"] },
+    go: { command: "gopls", args: ["serve"] },
+    java: { command: "jdtls", args: [] },
+};
+export class LspManager {
+    clients = new Map();
+    serverConfigs;
+    rootDir;
+    startingServers = new Map();
+    _workspace;
+    _workspaceReady = false;
+    _workspaceReadying = null;
+    _callbacks;
+    _sessionId;
+    _lombokJarPath = null;
+    _shuttingDown = false;
+    _restartAttempts = new Map();
+    _restartBackoff = new Map();
+    static MAX_RESTART_ATTEMPTS = 3;
+    static INITIAL_BACKOFF_MS = 1000;
+    static MAX_BACKOFF_MS = 30000;
+    constructor(rootDir, customConfigs, callbacks, sessionId, workspace) {
+        this.rootDir = resolve(rootDir);
+        this.serverConfigs = new Map(Object.entries({
+            ...DEFAULT_SERVERS,
+            ...customConfigs,
+        }));
+        this._workspace = workspace ?? new DefaultWorkspaceProvider();
+        this._callbacks = callbacks ?? {};
+        this._sessionId = sessionId ?? `${process.pid}-${Date.now()}`;
+    }
+    /** Get the workspace provider */
+    get workspace() {
+        return this._workspace;
+    }
+    /** Replace the workspace provider (e.g. when an external extension registers one) */
+    setWorkspaceProvider(provider) {
+        this._workspace = provider;
+        this._workspaceReady = false;
+        this._workspaceReadying = null;
+    }
+    /** Update or add a server configuration */
+    setServerConfig(languageId, config) {
+        this.serverConfigs.set(languageId, config);
+    }
+    /** Set an explicit path to a Lombok jar for Java/jdtls support */
+    setLombokJar(jarPath) {
+        this._lombokJarPath = resolve(this.rootDir, jarPath);
+    }
+    /** Get the currently configured Lombok jar path (if any) */
+    getLombokJar() {
+        return this.findLombokJar();
+    }
+    /**
+     * Auto-detect Lombok jar.
+     * Searches: explicit path, LOMBOK_JAR env var, workspace root env/ directories.
+     */
+    findLombokJar() {
+        // 1. Explicit path set via setLombokJar()
+        if (this._lombokJarPath) {
+            if (existsSync(this._lombokJarPath))
+                return this._lombokJarPath;
+        }
+        // 2. LOMBOK_JAR environment variable
+        const envJar = process.env.LOMBOK_JAR;
+        if (envJar) {
+            const resolved = resolve(this.rootDir, envJar);
+            if (existsSync(resolved))
+                return resolved;
+        }
+        // 3. Auto-detect from workspace root (e.g. Brazil workspace env/ directory)
+        //    Search both workspace root and cwd in case they differ
+        const searchRoots = [this.rootDir];
+        const wsRoot = this._workspace.workspaceRoot;
+        if (wsRoot && wsRoot !== this.rootDir) {
+            searchRoots.unshift(wsRoot);
+        }
+        for (const root of searchRoots) {
+            const envDir = join(root, "env");
+            if (!existsSync(envDir))
+                continue;
+            // env/Lombok-{version}/runtime/lib/lombok-*.jar
+            try {
+                const lombokDirs = readdirSync(envDir).filter(d => d.startsWith("Lombok-"));
+                for (const dir of lombokDirs) {
+                    const libDir = join(envDir, dir, "runtime", "lib");
+                    if (existsSync(libDir)) {
+                        const jars = readdirSync(libDir).filter(f => f.startsWith("lombok-") && f.endsWith(".jar"));
+                        if (jars.length > 0)
+                            return join(libDir, jars[0]);
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            // env/gradle-cache-2/org/projectlombok/lombok/{version}/lombok-{version}.jar
+            const gradleLombok = join(envDir, "gradle-cache-2", "org", "projectlombok", "lombok");
+            if (existsSync(gradleLombok)) {
+                try {
+                    const versions = readdirSync(gradleLombok);
+                    for (const ver of versions) {
+                        const jarPath = join(gradleLombok, ver, `lombok-${ver}.jar`);
+                        if (existsSync(jarPath))
+                            return jarPath;
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        return null;
+    }
+    /** Build initializationOptions for Java (jdtls) with Lombok support */
+    getJavaInitializationOptions() {
+        const lombokJar = this.findLombokJar();
+        if (!lombokJar)
+            return undefined;
+        // jdtls expects flat dotted keys in settings, not nested objects
+        return {
+            settings: {
+                "java.jdt.ls.vmargs": `-javaagent:${lombokJar}`,
+            },
+        };
+    }
+    /** Get all configured languages */
+    getConfiguredLanguages() {
+        return [...this.serverConfigs.keys()];
+    }
+    /** Resolve a file path to a language ID */
+    getLanguageId(filePath) {
+        return getLanguageIdFromPath(filePath);
+    }
+    /** Get a file URI from a path */
+    getFileUri(filePath) {
+        const abs = resolve(this.rootDir, filePath);
+        return pathToFileURL(abs).toString();
+    }
+    /** Resolve an absolute path from potentially relative input */
+    resolvePath(filePath) {
+        return resolve(this.rootDir, filePath);
+    }
+    /**
+     * Get the LSP client for a language ONLY if it's already running.
+     * Does not start a new server. Returns null if no client is active.
+     */
+    getRunningClient(languageId) {
+        const existing = this.clients.get(languageId);
+        if (existing && existing.initialized && !existing.disposed) {
+            return existing;
+        }
+        return null;
+    }
+    /**
+     * Get the LSP client for a file, starting the server if needed.
+     * Returns null if no server is configured for this file type.
+     */
+    async getClientForFile(filePath) {
+        const languageId = this.getLanguageId(filePath);
+        if (!languageId)
+            return null;
+        return this.getClientForLanguage(languageId);
+    }
+    /**
+     * Get a user-friendly message about why no client is available for a file.
+     */
+    getUnavailableReason(filePath) {
+        const languageId = this.getLanguageId(filePath);
+        if (!languageId)
+            return `No LSP server configured for file type: ${filePath}`;
+        const waitHint = this.getExpectedStartTime(languageId);
+        if (this.startingServers.has(languageId)) {
+            return `LSP server for ${languageId} is starting. ${waitHint} Retry shortly.`;
+        }
+        const existing = this.clients.get(languageId);
+        if (existing && !existing.initialized && !existing.disposed) {
+            return `LSP server for ${languageId} is initializing. ${waitHint} Retry shortly.`;
+        }
+        return `No LSP server available for: ${filePath}. If you just opened this project, call any LSP tool on a file to trigger server startup.`;
+    }
+    /** Estimated startup time hint for a language server */
+    getExpectedStartTime(languageId) {
+        switch (languageId) {
+            case "java":
+                return "This typically takes 1-5 minutes for Java (project indexing).";
+            case "rust":
+                return "This typically takes 30s-2min for Rust (cargo metadata + indexing).";
+            case "typescript":
+            case "javascript":
+            case "typescriptreact":
+            case "javascriptreact":
+                return "This typically takes 10-30s for TypeScript/JavaScript.";
+            case "python":
+                return "This typically takes 10-30s for Python.";
+            case "go":
+                return "This typically takes 10-30s for Go.";
+            default:
+                return "This may take a few seconds to a minute.";
+        }
+    }
+    /**
+     * Get the LSP client for a language, starting the server if needed.
+     * In Brazil workspaces, connects to a shared daemon (or spawns one).
+     * Returns null if no server is configured for this language.
+     */
+    async getClientForLanguage(languageId) {
+        // Already running?
+        const existing = this.clients.get(languageId);
+        if (existing && existing.initialized && !existing.disposed) {
+            return existing;
+        }
+        // Already starting? Don't block — return null so tools can show "starting" message
+        const starting = this.startingServers.get(languageId);
+        if (starting)
+            return null;
+        const config = this.serverConfigs.get(languageId);
+        if (!config)
+            return null;
+        // Kick off server start in the background — don't await
+        const startPromise = this.startServer(languageId, config);
+        this.startingServers.set(languageId, startPromise);
+        // Fire-and-forget: clean up on completion or failure
+        startPromise.catch((err) => {
+            this.startingServers.delete(languageId);
+            const message = `Failed to start LSP server for ${languageId}: ${err.message}`;
+            this._callbacks.onServerError?.(languageId, message);
+        });
+        return null; // Server not ready yet
+    }
+    /**
+     * Check if a server is currently starting up for a language.
+     */
+    isServerStarting(languageId) {
+        return this.startingServers.has(languageId);
+    }
+    /**
+     * Eagerly start LSP servers for the given languages in the background.
+     * Unlike getClientForLanguage (which returns null immediately), this method
+     * is fire-and-forget — intended for session_start auto-start.
+     */
+    startEagerly(languageIds) {
+        for (const languageId of languageIds) {
+            // Skip if already running or starting
+            const existing = this.clients.get(languageId);
+            if (existing && existing.initialized && !existing.disposed)
+                continue;
+            if (this.startingServers.has(languageId))
+                continue;
+            const config = this.serverConfigs.get(languageId);
+            if (!config)
+                continue;
+            const startPromise = this.startServer(languageId, config);
+            this.startingServers.set(languageId, startPromise);
+            startPromise.catch((err) => {
+                this.startingServers.delete(languageId);
+                this._callbacks.onServerError?.(languageId, `Auto-start failed: ${err.message}`);
+            });
+        }
+    }
+    /**
+     * Ensure workspace provider is ready (one-time per session).
+     * Deduplicates concurrent calls.
+     */
+    async ensureWorkspace() {
+        if (this._workspaceReady)
+            return;
+        if (this._workspaceReadying) {
+            await this._workspaceReadying;
+            return;
+        }
+        this._callbacks.onWorkspaceSetupStart?.();
+        const start = Date.now();
+        this._workspaceReadying = this._workspace.ensureReady(this._sessionId);
+        try {
+            const success = await this._workspaceReadying;
+            this._callbacks.onWorkspaceSetupEnd?.(success, Date.now() - start);
+        }
+        finally {
+            this._workspaceReady = true;
+            this._workspaceReadying = null;
+        }
+    }
+    async startServer(languageId, config) {
+        // Ensure workspace provider is ready (one-time setup)
+        await this.ensureWorkspace();
+        const stateDir = this._workspace.stateDir;
+        const folders = this._workspace.getWorkspaceFolders();
+        const workspaceFolders = folders.length > 0 ? folders : undefined;
+        // Build language-specific initializationOptions (e.g. Lombok for Java)
+        // Use config-level initializationOptions if provided, otherwise fall back to language-specific defaults
+        const initializationOptions = config.initializationOptions
+            ?? (languageId === "java" ? this.getJavaInitializationOptions() : undefined);
+        // For Java with Lombok, inject --jvm-arg so jdtls launches with -javaagent
+        let effectiveArgs = config.args;
+        if (languageId === "java") {
+            const lombokJar = this.findLombokJar();
+            if (lombokJar) {
+                effectiveArgs = [`--jvm-arg=-javaagent:${lombokJar}`, ...config.args];
+            }
+        }
+        // Callback for auto-restart on unexpected exit
+        const onUnexpectedExit = (code) => this.handleUnexpectedExit(languageId, code);
+        // Try connecting to an existing daemon socket first
+        const socketPath = this.getSocketPath(languageId);
+        if (socketPath && this.isDaemonAlive(languageId)) {
+            this._callbacks.onServerStart?.(languageId, `${config.command} (shared)`);
+            try {
+                const client = new LspClient({
+                    command: config.command,
+                    args: effectiveArgs,
+                    rootDir: this.rootDir,
+                    languageId,
+                    socketPath,
+                    initializationOptions,
+                    settings: config.settings,
+                    onUnexpectedExit,
+                });
+                await client.start();
+                this.clients.set(languageId, client);
+                this.startingServers.delete(languageId);
+                this._callbacks.onServerReady?.(languageId);
+                this._restartAttempts.delete(languageId);
+                this._restartBackoff.delete(languageId);
+                this.triggerPostInit(languageId, client);
+                return client;
+            }
+            catch {
+                // Daemon may be stale — fall through to spawn new one
+            }
+        }
+        // No existing daemon — spawn one (or start direct if no state directory)
+        this._callbacks.onServerStart?.(languageId, config.command);
+        if (stateDir) {
+            // Spawn daemon and connect via socket
+            try {
+                await this.spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions);
+                // Small delay to let daemon start listening
+                await new Promise((r) => setTimeout(r, DAEMON_SOCKET_READY_DELAY_MS));
+                const daemonSocket = this.getSocketPath(languageId);
+                // Retry connection (daemon may still be initializing jdtls which can take minutes)
+                let lastErr = null;
+                for (let attempt = 0; attempt < DAEMON_MAX_RETRIES; attempt++) {
+                    try {
+                        const client = new LspClient({
+                            command: config.command,
+                            args: effectiveArgs,
+                            rootDir: this.rootDir,
+                            languageId,
+                            socketPath: daemonSocket,
+                            initializationOptions,
+                            settings: config.settings,
+                            onUnexpectedExit,
+                        });
+                        await client.start();
+                        this.clients.set(languageId, client);
+                        this.startingServers.delete(languageId);
+                        this._callbacks.onServerReady?.(languageId);
+                        this._restartAttempts.delete(languageId);
+                        this._restartBackoff.delete(languageId);
+                        this.triggerPostInit(languageId, client);
+                        return client;
+                    }
+                    catch (err) {
+                        lastErr = err;
+                        // Check if daemon is still alive before retrying
+                        if (!this.isDaemonAlive(languageId)) {
+                            throw new Error(`Daemon for ${languageId} died during startup: ${err.message}`);
+                        }
+                        await new Promise((r) => setTimeout(r, DAEMON_RETRY_INTERVAL_MS));
+                    }
+                }
+                throw lastErr ?? new Error("Failed to connect to daemon");
+            }
+            catch (err) {
+                // Fall back to direct mode — log the daemon failure
+                this._callbacks.onServerError?.(languageId, `Daemon mode failed, falling back to direct: ${err.message}`);
+                this.startingServers.delete(languageId);
+                // Don't throw — try direct mode below
+            }
+        }
+        // Direct mode (no state directory for daemon, or daemon failed)
+        const client = new LspClient({
+            command: config.command,
+            args: effectiveArgs,
+            rootDir: this.rootDir,
+            languageId,
+            env: config.env,
+            workspaceFolders,
+            initializationOptions,
+            settings: config.settings,
+            onUnexpectedExit,
+        });
+        try {
+            await client.start();
+            this.clients.set(languageId, client);
+            this.startingServers.delete(languageId);
+            this._callbacks.onServerReady?.(languageId);
+            this._restartAttempts.delete(languageId);
+            this._restartBackoff.delete(languageId);
+            this.triggerPostInit(languageId, client);
+            return client;
+        }
+        catch (err) {
+            this.startingServers.delete(languageId);
+            const message = `Failed to start LSP server for ${languageId} (${config.command}): ${err.message}`;
+            this._callbacks.onServerError?.(languageId, message);
+            throw new Error(message);
+        }
+    }
+    /**
+     * Post-initialization hook for language-specific setup.
+     * For Java/jdtls: triggers a workspace build so diagnostics refresh
+     * after Lombok annotation processing completes.
+     */
+    triggerPostInit(languageId, client) {
+        if (languageId === "java") {
+            // java/buildWorkspace forces jdtls to rebuild and re-publish diagnostics.
+            // The boolean parameter means "full build" (true) vs incremental (false).
+            client.sendRequest("java/buildWorkspace", true).catch(() => {
+                // Not critical — diagnostics will just be stale until a file changes
+            });
+        }
+    }
+    /** Get the socket path for a language's daemon */
+    getSocketPath(languageId) {
+        const stateDir = this._workspace.stateDir;
+        if (!stateDir)
+            return null;
+        return join(stateDir, "sockets", `lsp-${languageId}.sock`);
+    }
+    /** Check if a daemon is alive for this language */
+    isDaemonAlive(languageId) {
+        const stateDir = this._workspace.stateDir;
+        if (!stateDir)
+            return false;
+        const pidPath = join(stateDir, "sockets", `lsp-${languageId}.pid`);
+        try {
+            if (!existsSync(pidPath))
+                return false;
+            const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+            if (isNaN(pid))
+                return false;
+            process.kill(pid, 0); // throws if not alive
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Spawn an LSP daemon as a detached background process */
+    async spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions) {
+        const socketPath = this.getSocketPath(languageId);
+        const daemonScript = new URL("./lsp-daemon.ts", import.meta.url).pathname;
+        const launcherScript = new URL("./lsp-daemon-launcher.cjs", import.meta.url).pathname;
+        // Resolve jiti from the running process's module context
+        let jitiPath;
+        try {
+            jitiPath = require.resolve("jiti");
+        }
+        catch {
+            try {
+                jitiPath = require.resolve("@mariozechner/jiti");
+            }
+            catch {
+                throw new Error("Cannot resolve jiti for daemon spawn — jiti not found in module path");
+            }
+        }
+        const env = {
+            ...process.env,
+            ...(config.env ?? {}),
+            LSP_ROOT_DIR: this.rootDir,
+            LSP_LANGUAGE_ID: languageId,
+        };
+        if (workspaceFolders && workspaceFolders.length > 0) {
+            env.LSP_WORKSPACE_FOLDERS = JSON.stringify(workspaceFolders);
+        }
+        if (initializationOptions) {
+            env.LSP_INITIALIZATION_OPTIONS = JSON.stringify(initializationOptions);
+        }
+        if (config.settings) {
+            env.LSP_SETTINGS = JSON.stringify(config.settings);
+        }
+        const child = spawnChild(process.execPath, // node
+        [launcherScript, jitiPath, daemonScript, socketPath, config.command, ...effectiveArgs], {
+            cwd: this.rootDir,
+            env,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref(); // let daemon outlive this process
+    }
+    /** Get status of all configured/running servers */
+    getStatus() {
+        const statuses = [];
+        for (const [languageId, config] of this.serverConfigs) {
+            const client = this.clients.get(languageId);
+            let diagnosticsCount = 0;
+            if (client) {
+                for (const diags of client.getAllDiagnostics().values()) {
+                    diagnosticsCount += diags.length;
+                }
+            }
+            const daemonAlive = this.isDaemonAlive(languageId);
+            statuses.push({
+                languageId,
+                command: config.command,
+                running: client?.initialized === true && !client.disposed,
+                diagnosticsCount,
+                shared: daemonAlive,
+            });
+        }
+        return statuses;
+    }
+    /**
+     * Handle an unexpected server exit. Attempts auto-restart with exponential backoff.
+     * Gives up after MAX_RESTART_ATTEMPTS failures per language per session.
+     */
+    handleUnexpectedExit(languageId, code) {
+        if (this._shuttingDown)
+            return;
+        // Clean up the dead client
+        this.clients.delete(languageId);
+        this.startingServers.delete(languageId);
+        const attempts = this._restartAttempts.get(languageId) ?? 0;
+        if (attempts >= LspManager.MAX_RESTART_ATTEMPTS) {
+            this._callbacks.onServerError?.(languageId, `LSP server for ${languageId} crashed ${attempts} times — giving up auto-restart`);
+            this._callbacks.onServerCrash?.(languageId, false, attempts);
+            return;
+        }
+        const backoff = this._restartBackoff.get(languageId) ?? LspManager.INITIAL_BACKOFF_MS;
+        this._restartAttempts.set(languageId, attempts + 1);
+        this._restartBackoff.set(languageId, Math.min(backoff * 2, LspManager.MAX_BACKOFF_MS));
+        this._callbacks.onServerCrash?.(languageId, true, attempts + 1);
+        setTimeout(() => {
+            if (this._shuttingDown)
+                return;
+            const config = this.serverConfigs.get(languageId);
+            if (!config)
+                return;
+            const startPromise = this.startServer(languageId, config);
+            this.startingServers.set(languageId, startPromise);
+            startPromise.catch((err) => {
+                this.startingServers.delete(languageId);
+                this._callbacks.onServerError?.(languageId, `Auto-restart failed for ${languageId}: ${err.message}`);
+                // Trigger another restart attempt (recursive backoff)
+                this.handleUnexpectedExit(languageId, null);
+            });
+        }, backoff);
+    }
+    /** Shut down all clients (disconnect from daemons, kill direct servers) */
+    async shutdownAll() {
+        this._workspace.shutdown();
+        this._shuttingDown = true;
+        const shutdowns = [...this.clients.values()].map((client) => client.shutdown().catch(() => { }));
+        await Promise.all(shutdowns);
+        this.clients.clear();
+        this.startingServers.clear();
+    }
+    /**
+     * Restart a specific language server. Shuts down the existing client
+     * (and kills the daemon if shared), then starts a fresh server.
+     * Returns once the new server is initialized, or throws on failure.
+     */
+    async restartServer(languageId) {
+        // Shut down existing client
+        const existing = this.clients.get(languageId);
+        if (existing) {
+            await existing.shutdown().catch(() => { });
+            this.clients.delete(languageId);
+        }
+        // Kill the daemon if one is running (so we get a fresh server with new config)
+        this.killDaemon(languageId);
+        // Wait for pending starts to clear
+        const pending = this.startingServers.get(languageId);
+        if (pending) {
+            await pending.catch(() => { });
+            this.startingServers.delete(languageId);
+        }
+        // Start fresh
+        const config = this.serverConfigs.get(languageId);
+        if (!config)
+            throw new Error(`No server configured for ${languageId}`);
+        await this.startServer(languageId, config);
+    }
+    /** Kill a running daemon for a language (if any) */
+    killDaemon(languageId) {
+        const stateDir = this._workspace.stateDir;
+        if (!stateDir)
+            return;
+        const pidPath = join(stateDir, "sockets", `lsp-${languageId}.pid`);
+        try {
+            if (!existsSync(pidPath))
+                return;
+            const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+            if (isNaN(pid))
+                return;
+            process.kill(pid, "SIGTERM");
+            // Clean up socket and pid files
+            const socketPath = join(stateDir, "sockets", `lsp-${languageId}.sock`);
+            try {
+                unlinkSync(socketPath);
+            }
+            catch { }
+            try {
+                unlinkSync(pidPath);
+            }
+            catch { }
+        }
+        catch {
+            // Process may already be dead
+        }
+    }
+}
+//# sourceMappingURL=lsp-manager.js.map