feat: Provide workspace to LSP servers and containers

Author: observerw

examples/pyright_container.py

@@ -18,11 +18,9 @@ async def main():
     # Set up workspace directory and mount it in Docker
     workspace = Path.cwd()
     async with PyrightClient(
-        # here we use `PyrightContainerServer`
-        server=PyrightContainerServer(
-            mounts=[workspace]  # Mount workspace into container
-        ),
         workspace=workspace,
+        # here we use the containerized Pyright server
+        server=PyrightContainerServer(),
     ) as client:
         # Find definition of PyrightContainerServer at line 12, column 28
         refs = await client.request_definition_locations(

src/lsp_client/client/abc.py

@@ -10,7 +10,7 @@
 import anyio
 import asyncer
 from anyio import AsyncContextManagerMixin
-from attrs import Factory, define, field
+from attrs import define, field
 from loguru import logger
 
 from lsp_client.capability.build import (
@@ -51,20 +51,16 @@ class LSPClient(
     AsyncContextManagerMixin,
     ABC,
 ):
-    _server: LSPServer = field(
-        alias="server",
-        default=Factory(lambda self: self.create_default_server(), takes_self=True),
-    )
-
+    _server: LSPServer | None = field(alias="server", default=None)
     _workspace: RawWorkspace = field(alias="workspace", factory=Path.cwd)
+
     sync_file: bool = True
     request_timeout: float = 5.0
 
     _buffer: LSPFileBuffer = field(factory=LSPFileBuffer, init=False)
 
-    @property
-    def server(self) -> LSPServer:
-        return self._server
+    def get_server(self) -> LSPServer:
+        return self._server or self.create_default_server()
 
     @override
     def get_workspace(self) -> Workspace:
@@ -241,7 +237,7 @@ async def __asynccontextmanager__(self) -> AsyncGenerator[Self]:
         async with (
             asyncer.create_task_group() as tg,
             channel[ServerRequest].create() as (sender, receiver),
-            self._server.serve(sender=sender),
+            self._server.serve(workspace=self.get_workspace(), sender=sender),
         ):
             # start to receive server requests here,
             # since server notification can be sent before `initialize`

src/lsp_client/server/abc.py

@@ -18,6 +18,7 @@
 )
 from lsp_client.server.types import ServerRequest
 from lsp_client.utils.channel import Sender
+from lsp_client.utils.workspace import Workspace
 
 
 @define(kw_only=True)
@@ -40,7 +41,7 @@ async def kill(self) -> None:
 
     @abstractmethod
     @asynccontextmanager
-    def run_process(self) -> AsyncGenerator[None]:
+    def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:
         """Run the server process."""
 
     async def _dispatch(self, sender: Sender[ServerRequest] | None) -> None:
@@ -82,12 +83,14 @@ async def notify(self, notification: RawNotification) -> None:
 
     @asynccontextmanager
     async def serve(
-        self, *, sender: Sender[ServerRequest] | None = None
+        self,
+        workspace: Workspace,
+        *,
+        sender: Sender[ServerRequest] | None = None,
     ) -> AsyncGenerator[Self]:
         async with (
-            self.run_process(),
+            self.run_process(workspace),
             asyncer.create_task_group() as tg,
         ):
             tg.soonify(self._dispatch)(sender)
-
             yield self

src/lsp_client/server/container.py

@@ -5,11 +5,12 @@
 from pathlib import Path
 from typing import Annotated, Literal, final, override
 
-from attrs import define, field
+from attrs import Factory, define, field
 from loguru import logger
 from pydantic import BaseModel, Field
 
 from lsp_client.jsonrpc.parse import RawPackage
+from lsp_client.utils.workspace import Workspace
 
 from .abc import LSPServer
 from .local import LocalServer
@@ -35,7 +36,7 @@ def __str__(self) -> str:
 
 
 class BindMount(MountBase):
-    type: Literal["bind"] = "bind"
+    type: str = "bind"
 
     bind_propagation: (
         Literal["private", "rprivate", "shared", "rshared", "slave", "rslave"] | None
@@ -63,7 +64,7 @@ def from_path(cls, path: Path) -> BindMount:
 
 
 class VolumeMount(MountBase):
-    type: Literal["volume"] = "volume"
+    type: str = "volume"
 
     volume_driver: str | None = None
     volume_subpath: str | None = None
@@ -87,7 +88,7 @@ def _parts(self) -> list[str]:
 
 
 class TmpfsMount(MountBase):
-    type: Literal["tmpfs"] = "tmpfs"
+    type: str = "tmpfs"
 
     tmpfs_size: int | None = None
     tmpfs_mode: int | None = None
@@ -114,7 +115,6 @@ def _parts(self) -> list[str]:
 def _format_mount(mount: Mount) -> str:
     if isinstance(mount, Path):
         mount = BindMount.from_path(mount)
-
     return str(mount)
 
 
@@ -124,23 +124,55 @@ class ContainerServer(LSPServer):
     """Runtime for container backend, e.g. `docker` or `podman`."""
 
     image: str
-    mounts: list[Mount]
+    """The container image to use."""
+
+    workdir: Path = Path("/workspace")
+    """The working directory inside the container."""
+
+    mounts: list[Mount] = Factory(list)
+    """List of extra mounts to be mounted inside the container."""
 
     backend: Literal["docker", "podman"] = "docker"
+    """The container backend to use. Can be either `docker` or `podman`."""
+
     container_name: str | None = None
+    """Optional name for the container."""
+
     extra_container_args: list[str] | None = None
+    """Extra arguments to pass to the container runtime."""
 
     _local: LocalServer = field(init=False)
 
-    def format_command(self) -> list[str]:
+    def format_command(self, workspace: Workspace) -> list[str]:
         cmd = [self.backend, "run", "--rm", "-i"]
 
         if self.container_name:
             cmd.extend(("--name", self.container_name))
 
-        for mount in self.mounts:
+        mounts = list(self.mounts)
+
+        match workspace.to_folders():
+            case [folder]:
+                mount = BindMount(
+                    source=str(folder.path),
+                    target=self.workdir.as_posix(),
+                )
+                mounts.append(mount)
+            case folders:
+                mounts.extend(
+                    BindMount(
+                        source=str(folder.path),
+                        target=(self.workdir / folder.name).as_posix(),
+                    )
+                    for folder in folders
+                )
+
+        for mount in mounts:
             cmd.extend(("--mount", _format_mount(mount)))
 
+        # Set working directory
+        cmd.extend(("--workdir", self.workdir.as_posix()))
+
         if self.extra_container_args:
             cmd.extend(self.extra_container_args)
 
@@ -162,8 +194,8 @@ async def kill(self) -> None:
 
     @override
     @asynccontextmanager
-    async def run_process(self) -> AsyncGenerator[None]:
-        command = self.format_command()
+    async def run_process(self, workspace: Workspace) -> AsyncGenerator[None]:
+        command = self.format_command(workspace)
         logger.debug("Running docker runtime with command: {}", command)
 
         self._local = LocalServer(command=command)

src/lsp_client/utils/workspace.py

@@ -19,9 +19,6 @@ def path(self) -> Path:
         return from_local_uri(self.uri)
 
 
-# type Workspace = Mapping[str, WorkspaceFolder]
-
-
 class Workspace(dict[str, WorkspaceFolder]):
     def to_folders(self) -> list[WorkspaceFolder]:
         return list(self.values())
@@ -38,10 +35,10 @@ def to_folders(self) -> list[WorkspaceFolder]:
     }
 )
 
-type RawWorkspace = AnyPath | Mapping[str, AnyPath]
+type RawWorkspace = AnyPath | Mapping[str, AnyPath] | Workspace
 
 
-def workspace_converter(raw: RawWorkspace) -> Workspace:
+def format_workspace(raw: RawWorkspace) -> Workspace:
     match raw:
         case str() | os.PathLike() as root_folder_path:
             return Workspace(
@@ -52,6 +49,8 @@ def workspace_converter(raw: RawWorkspace) -> Workspace:
                     )
                 }
             )
+        case Workspace() as ws:
+            return ws
         case _ as mapping:
             return Workspace(
                 {