lsp-devtools 0.2.2__tar.gz → 0.2.3__tar.gz

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/CHANGES.md

@@ -1,3 +1,16 @@
+## v0.2.3 - 2024-05-22
+
+
+### Enhancements
+
+- The `lsp-devtools agent` now forwards the server's `stderr` channel ([#165](https://github.com/swyddfa/lsp-devtools/issues/165))
+
+### Fixes
+
+- All `lsp-devtools` commands should no longer crash when encountering messages containing unicode characters ([#157](https://github.com/swyddfa/lsp-devtools/issues/157))
+- Commands like `lsp-devtools record` should now continue to function after encountering an error ([#158](https://github.com/swyddfa/lsp-devtools/issues/158))
+
+
 ## v0.2.2 - 2024-01-29
 
 

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lsp-devtools
-Version: 0.2.2
+Version: 0.2.3
 Summary: Developer tooling for language servers
 Project-URL: Bug Tracker, https://github.com/swyddfa/lsp-devtools/issues
-Project-URL: Documentation, https://swyddfa.github.io/lsp-devtools/
+Project-URL: Documentation, https://lsp-devtools.readthedocs.io/en/latest/
 Project-URL: Source Code, https://github.com/swyddfa/lsp-devtools
 Author-email: Alex Carney <alcarneyme@gmail.com>
 License: MIT

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/hatch.toml

@@ -7,3 +7,10 @@ include = ["lsp_devtools", "tests", "CHANGES.md"]
 
 [build.targets.wheel]
 packages = ["lsp_devtools"]
+
+[envs.hatch-test]
+extra-dependencies = ["pytest-asyncio"]
+
+[envs.hatch-static-analysis]
+config-path = "ruff_defaults.toml"
+dependencies = ["ruff==0.4.4"]

lsp_devtools-0.2.3/lsp_devtools/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.3"

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/agent/__init__.py

@@ -1,57 +1,34 @@
 import argparse
 import asyncio
-import logging
 import subprocess
 import sys
 from typing import List
-from uuid import uuid4
 
 from .agent import Agent
+from .agent import RPCMessage
 from .agent import logger
+from .agent import parse_rpc_message
 from .client import AgentClient
-from .protocol import MESSAGE_TEXT_NOTIFICATION
-from .protocol import MessageText
 from .server import AgentServer
-from .server import parse_rpc_message
 
 __all__ = [
     "Agent",
     "AgentClient",
     "AgentServer",
+    "RPCMessage",
     "logger",
-    "MESSAGE_TEXT_NOTIFICATION",
-    "MessageText",
     "parse_rpc_message",
 ]
 
 
-class MessageHandler(logging.Handler):
-    """Logging handler that forwards captured JSON-RPC messages through to the
-    ``AgentServer`` instance."""
+async def forward_stderr(server: asyncio.subprocess.Process):
+    """Forward the server's stderr to the agent's stderr."""
+    if server.stderr is None:
+        return
 
-    def __init__(self, client: AgentClient, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.client = client
-        self.session = str(uuid4())
-        self._buffer: List[MessageText] = []
-
-    def emit(self, record: logging.LogRecord):
-        message = MessageText(
-            text=record.args[0],  # type: ignore
-            session=self.session,
-            timestamp=record.created,
-            source=record.__dict__["source"],
-        )
-
-        if not self.client.connected:
-            self._buffer.append(message)
-            return
-
-        # Send any buffered messages
-        while len(self._buffer) > 0:
-            self.client.protocol.message_text_notification(self._buffer.pop(0))
-
-        self.client.protocol.message_text_notification(message)
+    # EOF is signalled with an empty bytestring
+    while (line := await server.stderr.readline()) != b"":
+        sys.stderr.buffer.write(line)
 
 
 async def main(args, extra: List[str]):
@@ -60,7 +37,6 @@ async def main(args, extra: List[str]):
         return 1
 
     command, *arguments = extra
-
     server = await asyncio.create_subprocess_exec(
         command,
         *arguments,
@@ -68,18 +44,13 @@ async def main(args, extra: List[str]):
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
     )
-    agent = Agent(server, sys.stdin.buffer, sys.stdout.buffer)
-
     client = AgentClient()
-    handler = MessageHandler(client)
-    handler.setLevel(logging.INFO)
-
-    logger.setLevel(logging.INFO)
-    logger.addHandler(handler)
+    agent = Agent(server, sys.stdin.buffer, sys.stdout.buffer, client.forward_message)
 
     await asyncio.gather(
         client.start_tcp(args.host, args.port),
         agent.start(),
+        forward_stderr(server),
     )
 
 

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/agent/agent.py

@@ -2,35 +2,83 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import json
 import logging
 import re
 import sys
 import typing
+from datetime import datetime
+from datetime import timezone
 from functools import partial
+from uuid import uuid4
+
+import attrs
 
 if typing.TYPE_CHECKING:
+    from typing import Any
     from typing import BinaryIO
+    from typing import Callable
+    from typing import Coroutine
+    from typing import Dict
     from typing import Optional
     from typing import Set
     from typing import Tuple
+    from typing import Union
+
+    MessageHandler = Callable[[bytes], Union[None, Coroutine[Any, Any, None]]]
 
+UTC = timezone.utc
 logger = logging.getLogger("lsp_devtools.agent")
 
 
-async def forward_message(source: str, dest: asyncio.StreamWriter, message: bytes):
-    """Forward the given message to the destination channel"""
-    dest.write(message)
-    await dest.drain()
+@attrs.define
+class RPCMessage:
+    """A Json-RPC message."""
 
-    # Log the full message
-    logger.info(
-        "%s",
-        message.decode("utf8"),
-        extra={"source": source},
-    )
+    headers: Dict[str, str]
+
+    body: Dict[str, Any]
+
+    def __getitem__(self, key: str):
+        return self.headers[key]
+
+
+def parse_rpc_message(data: bytes) -> RPCMessage:
+    """Parse a JSON-RPC message from the given set of bytes."""
+
+    headers: Dict[str, str] = {}
+    body: Optional[Dict[str, Any]] = None
+    headers_complete = False
+
+    for line in data.split(b"\r\n"):
+        if line == b"":
+            if "Content-Length" not in headers:
+                raise ValueError("Missing 'Content-Length' header")
 
+            headers_complete = True
+            continue
 
-async def aio_readline(reader: asyncio.StreamReader, message_handler):
+        if headers_complete:
+            length = int(headers["Content-Length"])
+            if len(line) != length:
+                raise ValueError("Incorrect 'Content-Length'")
+
+            body = json.loads(line)
+            continue
+
+        if (idx := line.find(b":")) < 0:
+            raise ValueError(f"Invalid header: {line!r}")
+
+        name, value = line[:idx], line[idx + 1 :]
+        headers[name.decode("utf8").strip()] = value.decode("utf8").strip()
+
+    if body is None:
+        raise ValueError("Missing message body")
+
+    return RPCMessage(headers, body)
+
+
+async def aio_readline(reader: asyncio.StreamReader, message_handler: MessageHandler):
     CONTENT_LENGTH_PATTERN = re.compile(rb"^Content-Length: (\d+)\r\n$")
 
     # Initialize message buffer
@@ -90,11 +138,17 @@ class Agent:
     enabling them to be recorded."""
 
     def __init__(
-        self, server: asyncio.subprocess.Process, stdin: BinaryIO, stdout: BinaryIO
+        self,
+        server: asyncio.subprocess.Process,
+        stdin: BinaryIO,
+        stdout: BinaryIO,
+        handler: MessageHandler,
     ):
         self.stdin = stdin
         self.stdout = stdout
         self.server = server
+        self.handler = handler
+        self.session_id = str(uuid4())
 
         self._tasks: Set[asyncio.Task] = set()
         self.reader: Optional[asyncio.StreamReader] = None
@@ -105,14 +159,14 @@ class Agent:
         self.reader, self.writer = await get_streams(self.stdin, self.stdout)
 
         # Keep mypy happy
-        assert self.server.stdin
-        assert self.server.stdout
+        if self.server.stdin is None or self.server.stdout is None:
+            raise RuntimeError("Unable to find server I/O streams")
 
         # Connect stdin to the subprocess' stdin
         client_to_server = asyncio.create_task(
             aio_readline(
                 self.reader,
-                partial(forward_message, "client", self.server.stdin),
+                partial(self.forward_message, "client", self.server.stdin),
             ),
         )
         self._tasks.add(client_to_server)
@@ -121,7 +175,7 @@ class Agent:
         server_to_client = asyncio.create_task(
             aio_readline(
                 self.server.stdout,
-                partial(forward_message, "server", self.writer),
+                partial(self.forward_message, "server", self.writer),
             ),
         )
         self._tasks.add(server_to_client)
@@ -133,6 +187,30 @@ class Agent:
             self._watch_server_process(),
         )
 
+    async def forward_message(
+        self, source: str, dest: asyncio.StreamWriter, message: bytes
+    ):
+        """Forward the given message to the destination channel"""
+
+        # Forward the message as-is to the client/server
+        dest.write(message)
+        await dest.drain()
+
+        # Include some additional metadata before passing it onto the devtool.
+        # TODO: How do we make sure we choose the same encoding as `message`?
+        now = datetime.now(tz=UTC).isoformat()
+        fields = [
+            f"Message-Source: {source}\r\n".encode(),
+            f"Message-Session: {self.session_id}\r\n".encode(),
+            f"Message-Timestamp: {now}\r\n".encode(),
+            message,
+        ]
+
+        if inspect.iscoroutine(res := self.handler(b"".join(fields))):
+            task = asyncio.create_task(res)
+            self._tasks.add(task)
+            task.add_done_callback(self._tasks.discard)
+
     async def _watch_server_process(self):
         """Once the server process exits, ensure that the agent is also shutdown."""
         ret = await self.server.wait()
@@ -149,7 +227,7 @@ class Agent:
                 self.server.kill()
 
         args = {}
-        if sys.version_info.minor > 8:
+        if sys.version_info >= (3, 9):
             args["msg"] = "lsp-devtools agent is stopping."
 
         # Cancel the tasks connecting client to server

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/agent/client.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
 import asyncio
-from typing import Any
-from typing import Optional
+import typing
 
 import stamina
 from pygls.client import JsonRPCClient
@@ -9,6 +10,11 @@ from pygls.protocol import default_converter
 
 from lsp_devtools.agent.protocol import AgentProtocol
 
+if typing.TYPE_CHECKING:
+    from typing import Any
+    from typing import List
+    from typing import Optional
+
 # from websockets.client import WebSocketClientProtocol
 
 
@@ -39,6 +45,7 @@ class AgentClient(JsonRPCClient):
             protocol_cls=AgentProtocol, converter_factory=default_converter
         )
         self.connected = False
+        self._buffer: List[bytes] = []
 
     def _report_server_error(self, error, source):
         # Bail on error
@@ -71,6 +78,22 @@ class AgentClient(JsonRPCClient):
         self.connected = True
         self._async_tasks.append(connection)
 
+    def forward_message(self, message: bytes):
+        """Forward the given message to the server instance."""
+
+        if not self.connected:
+            self._buffer.append(message)
+            return
+
+        if self.protocol.transport is None:
+            return
+
+        # Send any buffered messages
+        while len(self._buffer) > 0:
+            self.protocol.transport.write(self._buffer.pop(0))
+
+        self.protocol.transport.write(message)
+
     # TODO: Upstream this... or at least something equivalent.
     # def start_ws(self, host: str, port: int):
     #     self.protocol._send_only_body = True  # Don't send headers within the payload

lsp_devtools-0.2.3/lsp_devtools/agent/protocol.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pygls.protocol import JsonRPCProtocol
+
+
+class AgentProtocol(JsonRPCProtocol):
+    """The RPC protocol exposed by the agent."""

lsp_devtools-0.2.3/lsp_devtools/agent/server.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import traceback
+import typing
+
+from pygls.protocol import default_converter
+from pygls.server import Server
+
+from lsp_devtools.agent.agent import aio_readline
+from lsp_devtools.agent.protocol import AgentProtocol
+from lsp_devtools.database import Database
+
+if typing.TYPE_CHECKING:
+    from typing import Any
+    from typing import List
+    from typing import Optional
+
+    from lsp_devtools.agent.agent import MessageHandler
+
+
+class AgentServer(Server):
+    """A pygls server that accepts connections from agents allowing them to send their
+    collected messages."""
+
+    lsp: AgentProtocol
+
+    def __init__(
+        self,
+        *args,
+        logger: Optional[logging.Logger] = None,
+        handler: Optional[MessageHandler] = None,
+        **kwargs,
+    ):
+        if "protocol_cls" not in kwargs:
+            kwargs["protocol_cls"] = AgentProtocol
+
+        if "converter_factory" not in kwargs:
+            kwargs["converter_factory"] = default_converter
+
+        super().__init__(*args, **kwargs)
+
+        self.logger = logger or logging.getLogger(__name__)
+        self.handler = handler or self.lsp.data_received
+        self.db: Optional[Database] = None
+
+        self._client_buffer: List[str] = []
+        self._server_buffer: List[str] = []
+        self._tcp_server: Optional[asyncio.Task] = None
+
+    def _report_server_error(self, exc: Exception, source):
+        """Report internal server errors."""
+        tb = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+        self.logger.error("%s: %s", type(exc).__name__, exc)
+        self.logger.debug("%s", tb)
+
+    def feature(self, feature_name: str, options: Optional[Any] = None):
+        return self.lsp.fm.feature(feature_name, options)
+
+    async def start_tcp(self, host: str, port: int) -> None:  # type: ignore[override]
+        async def handle_client(reader, writer):
+            self.lsp.connection_made(writer)
+
+            try:
+                await aio_readline(reader, self.handler)
+            except asyncio.CancelledError:
+                pass
+            finally:
+                writer.close()
+                await writer.wait_closed()
+
+            # Uncomment if we ever need to introduce a mode where the server stops
+            # automatically once a session ends.
+            #
+            # self.stop()
+
+        server = await asyncio.start_server(handle_client, host, port)
+        async with server:
+            self._tcp_server = asyncio.create_task(server.serve_forever())
+            await self._tcp_server
+
+    def stop(self):
+        if self._tcp_server is not None:
+            self._tcp_server.cancel()

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/client/__init__.py

@@ -69,7 +69,9 @@ class LSPClient(App):
 
     def compose(self) -> ComposeResult:
         message_viewer = MessageViewer("")
-        messages_table = MessagesTable(self.db, message_viewer, session=self.session)
+        messages_table = MessagesTable(
+            self.db, message_viewer, session=self.lsp_client.session_id
+        )
 
         yield Header()
         yield Explorer(".")
@@ -145,7 +147,7 @@ def client(args, extra: List[str]):
     db = Database(args.dbpath)
 
     session = str(uuid4())
-    dbhandler = DatabaseLogHandler(db, session=session)
+    dbhandler = DatabaseLogHandler(db)
     dbhandler.setLevel(logging.INFO)
 
     logger.setLevel(logging.INFO)

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/client/lsp.py

@@ -1,6 +1,9 @@
 import importlib.metadata
 import json
+from datetime import datetime
+from datetime import timezone
 from typing import Optional
+from uuid import uuid4
 
 from lsprotocol import types
 from pygls.lsp.client import BaseLanguageClient
@@ -8,6 +11,7 @@ from pygls.protocol import LanguageServerProtocol
 
 from lsp_devtools.agent import logger
 
+UTC = timezone.utc
 VERSION = importlib.metadata.version("lsp-devtools")
 
 
@@ -16,12 +20,17 @@ class RecordingLSProtocol(LanguageServerProtocol):
 
     def __init__(self, server, converter):
         super().__init__(server, converter)
+        self.session_id = ""
 
     def _procedure_handler(self, message):
         logger.info(
             "%s",
             json.dumps(message, default=self._serialize_message),
-            extra={"source": "server"},
+            extra={
+                "Message-Source": "server",
+                "Message-Session": self.session_id,
+                "Message-Timestamp": datetime.now(tz=UTC).isoformat(),
+            },
         )
         return super()._procedure_handler(message)
 
@@ -29,7 +38,11 @@ class RecordingLSProtocol(LanguageServerProtocol):
         logger.info(
             "%s",
             json.dumps(data, default=self._serialize_message),
-            extra={"source": "client"},
+            extra={
+                "Message-Source": "client",
+                "Message-Session": self.session_id,
+                "Message-Timestamp": datetime.now(tz=UTC).isoformat(),
+            },
         )
         return super()._send_data(data)
 
@@ -40,6 +53,8 @@ class LanguageClient(BaseLanguageClient):
     def __init__(self):
         super().__init__("lsp-devtools", VERSION, protocol_cls=RecordingLSProtocol)
 
+        self.session_id = str(uuid4())
+        self.protocol.session_id = self.session_id  # type: ignore[attr-defined]
         self._server_capabilities: Optional[types.ServerCapabilities] = None
 
     @property

{lsp_devtools-0.2.2 → lsp_devtools-0.2.3}/lsp_devtools/database.py

@@ -9,7 +9,6 @@ from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Set
-from uuid import uuid4
 
 import aiosqlite
 from textual.app import App
@@ -17,10 +16,10 @@ from textual.message import Message
 
 from lsp_devtools.handlers import LspMessage
 
-if sys.version_info.minor < 9:
+if sys.version_info < (3, 9):
     import importlib_resources as resources
 else:
-    import importlib.resources as resources  # type: ignore[no-redef]
+    from importlib import resources  # type: ignore[no-redef]
 
 
 class Database:
@@ -62,14 +61,14 @@ class Database:
 
         await self.db.commit()
 
-    async def add_message(self, session: str, timestamp: float, source: str, rpc: dict):
+    async def add_message(self, session: str, timestamp: str, source: str, rpc: dict):
         """Add a new rpc message to the database."""
 
-        msg_id = rpc.get("id", None)
-        method = rpc.get("method", None)
-        params = rpc.get("params", None)
-        result = rpc.get("result", None)
-        error = rpc.get("error", None)
+        msg_id = rpc.get("id")
+        method = rpc.get("method")
+        params = rpc.get("params")
+        result = rpc.get("result")
+        error = rpc.get("error")
 
         async with self.cursor() as cursor:
             await cursor.execute(
@@ -149,17 +148,19 @@ class Database:
 class DatabaseLogHandler(logging.Handler):
     """A logging handler that records messages in the given database."""
 
-    def __init__(self, db: Database, *args, session=None, **kwargs):
+    def __init__(self, db: Database, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.db = db
-        self.session = session or str(uuid4())
         self._tasks: Set[asyncio.Task] = set()
 
     def emit(self, record: logging.LogRecord):
         body = json.loads(record.args[0])  # type: ignore
         task = asyncio.create_task(
             self.db.add_message(
-                self.session, record.created, record.__dict__["source"], body
+                record.__dict__["Message-Session"],
+                record.__dict__["Message-Timestamp"],
+                record.__dict__["Message-Source"],
+                body,
             )
         )