fix idempotent LSP bootstrap

Author: bx33661

scripts/bootstrap.py

@@ -48,17 +48,20 @@ def install_wrapper(name: str, target: Path, arguments: list[str] | None = None)
     bin_dir = venv_bin_dir()
     bin_dir.mkdir(parents=True, exist_ok=True)
     arguments = arguments or []
+    wrapper = bin_dir / (f"{name}.cmd" if platform.system() == "Windows" else name)
+    if target.resolve() == wrapper.resolve():
+        raise RuntimeError(
+            f"Refusing to create a recursive wrapper for {name}: {wrapper}"
+        )
 
     if platform.system() == "Windows":
-        wrapper = bin_dir / f"{name}.cmd"
         rendered_args = " ".join(f'"{value}"' for value in arguments)
         wrapper.write_text(
             f'@echo off\r\n"{target}" {rendered_args} %*\r\n',
             encoding="utf-8",
         )
         return
 
-    wrapper = bin_dir / name
     rendered_args = " ".join(_shell_quote(value) for value in arguments)
     wrapper.write_text(
         f"#!/usr/bin/env sh\nexec {_shell_quote(str(target))} {rendered_args} \"$@\"\n",
@@ -145,23 +148,17 @@ def ensure_jdtls(allow_download: bool) -> None:
 
 def ensure_lsp_mcp(allow_build: bool) -> None:
     existing = shutil.which("mcp-language-server")
-    if existing:
+    wrapper = venv_bin_dir() / (
+        "mcp-language-server.cmd"
+        if platform.system() == "Windows"
+        else "mcp-language-server"
+    )
+    if existing and Path(existing).resolve() != wrapper.resolve():
         install_wrapper("mcp-language-server", Path(existing))
         log(f"[ok] LSP MCP bridge: {existing}")
         return
-    if not allow_build:
-        raise RuntimeError(
-            "mcp-language-server is missing and automatic build was disabled."
-        )
 
     require("go", "Install Go from https://go.dev/doc/install.")
-    run(
-        [
-            "go",
-            "install",
-            f"{MCP_LANGUAGE_SERVER_MODULE}@{MCP_LANGUAGE_SERVER_VERSION}",
-        ]
-    )
     go_path = subprocess.run(
         ["go", "env", "GOPATH"],
         check=True,
@@ -173,9 +170,22 @@ def ensure_lsp_mcp(allow_build: bool) -> None:
         if platform.system() == "Windows"
         else "mcp-language-server"
     )
+    if not executable.exists():
+        if not allow_build:
+            raise RuntimeError(
+                "mcp-language-server is missing and automatic build was disabled."
+            )
+        run(
+            [
+                "go",
+                "install",
+                f"{MCP_LANGUAGE_SERVER_MODULE}@{MCP_LANGUAGE_SERVER_VERSION}",
+            ]
+        )
     if not executable.exists():
         raise RuntimeError(f"Go installed bridge was not found at {executable}")
     install_wrapper("mcp-language-server", executable)
+    log(f"[ok] LSP MCP bridge: {executable}")
 
 
 def ensure_mcp_runtime() -> None:

scripts/smoke_source_lsp.py

@@ -5,7 +5,7 @@
 
 import argparse
 import asyncio
-import os
+import tempfile
 from contextlib import AsyncExitStack
 from pathlib import Path
 
@@ -33,6 +33,7 @@
 
 async def check_language(language: str) -> None:
     workspace, source_file = CASES[language]
+    source_path = str((workspace / source_file).resolve())
     connection = MCPLanguageConfigService().get_language_server_config(
         language,
         str(workspace),
@@ -44,38 +45,53 @@ async def check_language(language: str) -> None:
         env=connection.get("env"),
     )
 
-    async with AsyncExitStack() as stack:
-        errlog = stack.enter_context(open(os.devnull, "w", encoding="utf-8"))
-        read_stream, write_stream = await stack.enter_async_context(
-            stdio_client(parameters, errlog=errlog)
-        )
-        session = await stack.enter_async_context(
-            ClientSession(read_stream, write_stream)
-        )
-        await session.initialize()
-        tools = {tool.name for tool in (await session.list_tools()).tools}
-        required = {"definition", "references", "diagnostics", "hover"}
-        missing = required - tools
-        if missing:
-            raise RuntimeError(
-                f"{language}: bridge is missing tools: {', '.join(sorted(missing))}"
-            )
-        result = await session.call_tool(
-            "diagnostics",
-            {"filePath": source_file},
-        )
-        if result.isError:
-            detail = " ".join(
-                getattr(item, "text", str(item)) for item in result.content
-            )
-            raise RuntimeError(f"{language}: diagnostics failed: {detail}")
+    stage = "starting MCP bridge"
+    print(f"[check] {language}: {stage}", flush=True)
+    with tempfile.TemporaryFile(mode="w+", encoding="utf-8") as errlog:
+        try:
+            async with AsyncExitStack() as stack:
+                read_stream, write_stream = await stack.enter_async_context(
+                    stdio_client(parameters, errlog=errlog)
+                )
+                session = await stack.enter_async_context(
+                    ClientSession(read_stream, write_stream)
+                )
+                stage = "initializing MCP session"
+                async with asyncio.timeout(30):
+                    await session.initialize()
+                stage = "listing MCP tools"
+                async with asyncio.timeout(15):
+                    tools = {tool.name for tool in (await session.list_tools()).tools}
+                required = {"definition", "references", "diagnostics", "hover"}
+                missing = required - tools
+                if missing:
+                    raise RuntimeError(
+                        f"{language}: bridge is missing tools: "
+                        f"{', '.join(sorted(missing))}"
+                    )
+                stage = f"requesting diagnostics for {source_path}"
+                async with asyncio.timeout(30):
+                    result = await session.call_tool(
+                        "diagnostics",
+                        {"filePath": source_path},
+                    )
+                if result.isError:
+                    detail = " ".join(
+                        getattr(item, "text", str(item)) for item in result.content
+                    )
+                    raise RuntimeError(f"{language}: diagnostics failed: {detail}")
+        except Exception as exc:
+            errlog.seek(0)
+            server_log = errlog.read().strip()
+            detail = f"\nBridge stderr:\n{server_log}" if server_log else ""
+            raise RuntimeError(f"{language}: failed while {stage}: {exc}{detail}") from exc
 
     print(f"[ok] {language}: MCP handshake and diagnostics call succeeded")
 
 
 async def async_main(languages: list[str]) -> None:
     for language in languages:
-        await asyncio.wait_for(check_language(language), timeout=90)
+        await check_language(language)
 
 
 def main() -> None:

test/test_bootstrap.py

@@ -0,0 +1,26 @@
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+
+def _load_bootstrap_module():
+    path = Path(__file__).resolve().parents[1] / "scripts" / "bootstrap.py"
+    spec = importlib.util.spec_from_file_location("pure_auto_codeql_bootstrap", path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_install_wrapper_rejects_recursive_target(tmp_path: Path, monkeypatch) -> None:
+    bootstrap = _load_bootstrap_module()
+    bin_dir = tmp_path / "bin"
+    monkeypatch.setattr(bootstrap, "venv_bin_dir", lambda: bin_dir)
+    wrapper = bin_dir / "mcp-language-server"
+    wrapper.parent.mkdir(parents=True)
+    wrapper.write_text("#!/usr/bin/env sh\n", encoding="utf-8")
+
+    with pytest.raises(RuntimeError, match="recursive wrapper"):
+        bootstrap.install_wrapper("mcp-language-server", wrapper)