update

Author: observerw

.python-version

@@ -1 +1 @@
-3.14
+3.13

justfile

@@ -1,3 +1,6 @@
+sync:
+    uv sync --upgrade
+
 lint path='src':
     uv run ruff check --fix {{path}}
     uv run ruff format {{path}}

pyproject.toml

@@ -3,10 +3,9 @@ name = "lsp-cli"
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 dependencies = [
     "anyio>=4.12.0",
-    "aiohttp>=3.11.11",
     "asyncer>=0.0.12",
     "attrs>=25.4.0",
     "httpx>=0.28.1",
@@ -32,7 +31,6 @@ build-backend = "uv_build"
 
 [tool.uv.sources]
 lsap = { git = "https://github.com/lsp-client/LSAP.git", subdirectory = "python" }
-lsp-client = { git = "https://github.com/lsp-client/python-sdk.git" }
 
 [dependency-groups]
 dev = [

src/lsp_cli/__main__.py

@@ -23,12 +23,12 @@
 from lsap_schema.symbol_outline import SymbolOutlineRequest
 from lsap_schema.workspace_symbol import WorkspaceSymbolRequest
 from lsp_client import Client
-from lsp_client.server.socket import SocketServer
 from rich.console import Console
 
 from lsp_cli.client import find_client
 from lsp_cli.logging import setup_logging
 from lsp_cli.manager import CreateClientRequest, CreateClientResponse
+from lsp_cli.manager.client import ManagerServer
 from lsp_cli.server import app as server_app
 from lsp_cli.server import get_client
 
@@ -52,12 +52,13 @@ async def init_client(path: Path) -> AsyncGenerator[Client]:
     with get_client() as httpx:
         req = CreateClientRequest(path=path).model_dump(mode="json")
         resp = httpx.post("/create", json=req)
-        resp.raise_for_status()
-        resp = CreateClientResponse.model_validate(resp.json())
+        json = resp.raise_for_status().json()
+        resp = CreateClientResponse.model_validate(json)
 
     async with target.client_cls(
-        server=SocketServer(connection=resp.uds_path),
+        server=ManagerServer(uds_path=resp.uds_path),
         workspace=target.project_path,
+        unmanaged=True,
     ) as client:
         yield client
 
@@ -203,7 +204,7 @@ async def get_hover(
 @cli_syncify
 async def get_reference(
     file_path: op.FileArg,
-    line: Annotated[int | None, op.LineOpt] = None,
+    line: op.LineOpt,
     symbol: op.SymbolPathOpt = None,
     find: Annotated[str | None, op.FindOpt] = None,
     marker: op.MarkerOpt = "<HERE>",

src/lsp_cli/manager/client.py

@@ -1,21 +1,98 @@
 from __future__ import annotations
 
-from contextlib import AsyncExitStack
+from collections.abc import AsyncGenerator
+from contextlib import AsyncExitStack, asynccontextmanager
+from functools import cached_property
 from pathlib import Path
+from typing import Self, override
 
 import anyio
 import asyncer
+import httpx
+import loguru
 import uvicorn
 import xxhash
-from attrs import define, field
-from litestar import Litestar, post
+from attrs import Factory, define, field
+from litestar import Litestar, get, post
 from loguru import logger
-from lsp_client.jsonrpc.types import RawRequest, RawResponsePackage
+from lsp_client import Client
+from lsp_client.jsonrpc.types import (
+    RawNotification,
+    RawRequest,
+    RawRequestPackage,
+    RawResponsePackage,
+)
+from lsp_client.server import Server, ServerRuntimeError
+from lsp_client.server.types import ServerRequest
+from lsp_client.utils.channel import Sender
+from lsp_client.utils.workspace import Workspace, format_workspace
 
 from lsp_cli.client import TargetClient
-from lsp_cli.settings import RUNTIME_DIR, settings
+from lsp_cli.settings import LOG_DIR, RUNTIME_DIR, settings
 
-from .models import ManagedClientInfo
+from .models import HandshakeRequest, HandshakeResponse, ManagedClientInfo
+
+
+@define
+class ManagerServer(Server):
+    uds_path: Path
+
+    @cached_property
+    def client(self) -> httpx.AsyncClient:
+        transport = httpx.AsyncHTTPTransport(uds=self.uds_path.as_posix())
+        return httpx.AsyncClient(
+            transport=transport,
+            base_url="http://localhost",
+            timeout=None,
+        )
+
+    @override
+    async def check_availability(self) -> None:
+        if not self.uds_path.exists():
+            raise ServerRuntimeError(self, f"Server socket not found: {self.uds_path}")
+        try:
+            await self.client.get("/health")
+        except httpx.HTTPError as e:
+            raise ServerRuntimeError(
+                self, f"Managed server at {self.uds_path} is not responding: {e}"
+            ) from e
+
+    @override
+    async def request(self, request: RawRequest) -> RawResponsePackage:
+        response = await self.client.post("/", json=request)
+        return response.json()
+
+    @override
+    async def notify(self, notification: RawNotification) -> None:
+        await self.client.post("/", json=notification)
+
+    @override
+    async def kill(self) -> None:
+        # await self.client.post("/shutdown")
+        return
+
+    @override
+    @asynccontextmanager
+    async def run(
+        self, workspace: Workspace, sender: Sender[ServerRequest]
+    ) -> AsyncGenerator[Self]:
+        if False:
+            handshake = HandshakeRequest(
+                client_id=self.uds_path.stem,
+                workspace={name: folder.uri for name, folder in workspace.items()},
+            )
+            resp = await self.client.post(
+                "/handshake", content=handshake.model_dump_json()
+            )
+            json = resp.raise_for_status().json()
+            result = HandshakeResponse.model_validate(json)
+            if result.status != "ok":
+                raise ServerRuntimeError(
+                    self,
+                    f"Handshake rejected: {result.reason} (current: {result.current_client_id or result.current_workspace})",
+                )
+
+        yield self
 
 
 def get_client_id(target: TargetClient) -> str:
@@ -30,11 +107,15 @@ class ManagedClient:
     _server: uvicorn.Server | None = field(init=False, default=None)
     _timeout_scope: anyio.CancelScope | None = field(init=False, default=None)
     _server_scope: anyio.CancelScope | None = field(init=False, default=None)
-    _deadline: float = field(init=False)
-    _should_exit: bool = field(init=False, default=False)
 
-    def __attrs_post_init__(self) -> None:
-        self._deadline = anyio.current_time() + settings.idle_timeout
+    _deadline: float = Factory(lambda: anyio.current_time() + settings.idle_timeout)
+    _should_exit: bool = False
+
+    _log_handler_id: int | None = field(init=False, default=None)
+
+    @cached_property
+    def logger(self) -> loguru.Logger:
+        return logger.bind(client_id=self.id)
 
     @property
     def id(self) -> str:
@@ -53,6 +134,7 @@ def info(self) -> ManagedClientInfo:
         )
 
     def stop(self) -> None:
+        self.logger.info("Stopping managed client {}", self.id)
         self._should_exit = True
         if self._server:
             self._server.should_exit = True
@@ -62,22 +144,86 @@ def stop(self) -> None:
             self._timeout_scope.cancel()
 
     async def run(self) -> None:
+        client_log_dir = LOG_DIR / "clients"
+        client_log_dir.mkdir(parents=True, exist_ok=True)
+        self._log_handler_id = logger.add(
+            client_log_dir / f"{self.id}.log",
+            rotation="10 MB",
+            retention="1 day",
+            level="DEBUG",
+            filter=lambda record: record["extra"].get("client_id") == self.id,
+        )
+
+        self.logger.info(
+            "Starting managed client {} for project {} at {}",
+            self.id,
+            self.target.project_path,
+            self.uds_path,
+        )
         async with AsyncExitStack() as stack:
+            if self._log_handler_id is not None:
+                stack.callback(lambda: logger.remove(self._log_handler_id))
+
             uds_path = anyio.Path(self.uds_path)
             await uds_path.unlink(missing_ok=True)
             await uds_path.parent.mkdir(parents=True, exist_ok=True)
             stack.push_async_callback(uds_path.unlink, missing_ok=True)
 
-            lsp_client = await stack.enter_async_context(self.target.client_cls())
+            client: Client = await stack.enter_async_context(
+                self.target.client_cls(workspace=self.target.project_path)
+            )
+            self.logger.info("LSP client for {} initialized", self.id)
+
+            @get("/health")
+            async def health() -> str:
+                return "ok"
+
+            @post("/handshake")
+            async def handshake(data: HandshakeRequest) -> HandshakeResponse:
+                self.logger.debug("Handshake received for client {}", self.id)
+                self._reset_timeout()
+                if data.client_id != self.id:
+                    return HandshakeResponse(
+                        status="error",
+                        reason="id_mismatch",
+                        current_client_id=self.id,
+                    )
+                received_ws = format_workspace(data.workspace)
+                if client.get_workspace() != received_ws:
+                    return HandshakeResponse(
+                        status="error",
+                        reason="workspace_mismatch",
+                        current_workspace={
+                            name: folder.uri
+                            for name, folder in client.get_workspace().items()
+                        },
+                    )
+                return HandshakeResponse(status="ok")
+
+            @post("/shutdown")
+            async def shutdown() -> None:
+                self.logger.info("Shutdown requested for client {}", self.id)
+                self.stop()
 
             @post("/")
-            async def handle_request(data: RawRequest) -> RawResponsePackage:
+            async def handle_package(
+                data: RawRequestPackage,
+            ) -> RawResponsePackage | None:
                 self._reset_timeout()
-                return await lsp_client.get_server().request(data)
+                server = client.get_server()
+
+                match data:
+                    case {"id": _}:
+                        return await server.request(data)
+                    case _:
+                        await server.notify(data)
 
-            app = Litestar(route_handlers=[handle_request])
+            app = Litestar(route_handlers=[handle_package, health, shutdown])
             config = uvicorn.Config(
-                app, uds=str(self.uds_path), log_level="error", loop="asyncio"
+                app,
+                uds=str(self.uds_path),
+                log_level="error",
+                loop="asyncio",
             )
             self._server = uvicorn.Server(config)
 
@@ -112,7 +258,6 @@ async def _timeout_loop(self) -> None:
                 self._timeout_scope = scope
                 await anyio.sleep(remaining)
 
-        logger.info("Client {} idle timeout, shutting down", self.id)
         if self._server:
             self._server.should_exit = True
         if self._server_scope:

src/lsp_cli/manager/manager.py

@@ -19,7 +19,7 @@ class Manager:
     _clients: dict[str, ManagedClient] = Factory(dict)
     _tg: asyncer.TaskGroup = field(init=False)
 
-    async def create_client(self, path: Path) -> str:
+    async def create_client(self, path: Path) -> Path:
         target = find_client(path)
         if not target:
             raise NotFoundException(f"No LSP client found for path: {path}")
@@ -32,7 +32,7 @@ async def create_client(self, path: Path) -> str:
         else:
             self._clients[client_id]._reset_timeout()
 
-        return str(self._clients[client_id].uds_path)
+        return self._clients[client_id].uds_path
 
     @logger.catch(level="ERROR")
     async def _run_client(self, client: ManagedClient) -> None:

src/lsp_cli/manager/models.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import Literal
 
 from pydantic import BaseModel
 from rich import box
@@ -35,7 +36,7 @@ class CreateClientRequest(BaseModel):
 
 
 class CreateClientResponse(BaseModel):
-    uds_path: str
+    uds_path: Path
     info: ManagedClientInfo
 
 
@@ -45,3 +46,15 @@ class DeleteClientRequest(BaseModel):
 
 class DeleteClientResponse(BaseModel):
     info: ManagedClientInfo | None
+
+
+class HandshakeRequest(BaseModel):
+    client_id: str
+    workspace: dict[str, str]
+
+
+class HandshakeResponse(BaseModel):
+    status: Literal["ok", "error"]
+    reason: str | None = None
+    current_client_id: str | None = None
+    current_workspace: dict[str, str] | None = None

src/lsp_cli/manager/server.py

@@ -20,7 +20,7 @@
     LOG_DIR / "manager.log",
     rotation="1 day",
     retention="7 days",
-    level="INFO",
+    level="DEBUG",
 )
 
 
@@ -30,7 +30,9 @@ async def create_client_handler(
 ) -> CreateClientResponse:
     uds_path = await manager.create_client(data.path)
     info = manager.inspect_client(data.path)
-    assert info is not None
+    if not info:
+        raise RuntimeError("Failed to create client")
+
     return CreateClientResponse(uds_path=uds_path, info=info)
 
 
@@ -40,6 +42,7 @@ async def delete_client_handler(
 ) -> DeleteClientResponse:
     info = manager.inspect_client(data.path)
     await manager.delete_client(data.path)
+
     return DeleteClientResponse(info=info)