WIP: servers daemon

Author: observerw

src/lsp_client/cli/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .__main__ import app
+
+__all__ = ["app"]

src/lsp_client/cli/__main__.py

@@ -2,8 +2,12 @@
 
 import typer
 
+from . import servers
+
 app = typer.Typer(help="LSP Client CLI")
 
+app.add_typer(servers.app, name="servers")
+
 
 @app.command()
 def hover(

src/lsp_client/cli/daemon.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Literal
+
+import anyio
+from loguru import logger
+from pydantic import BaseModel, Field
+
+SOCKET_PATH = Path("/tmp/lsp_client_daemon.sock")
+
+
+class ServerInfo(BaseModel):
+    image: str
+    status: str = "running"
+
+
+class CreateParams(BaseModel):
+    name: str
+    image: str
+
+
+class StopParams(BaseModel):
+    name: str
+
+
+class ListParams(BaseModel): ...
+
+
+class DaemonRequest(BaseModel):
+    command: Literal["create", "list", "stop"]
+    params: CreateParams | StopParams | ListParams = Field(default_factory=ListParams)
+
+
+class DaemonResponse(BaseModel):
+    status: str
+    message: str | None = None
+    servers: dict[str, ServerInfo] | None = None
+
+
+class Daemon:
+    def __init__(self):
+        self.servers: dict[str, ServerInfo] = {}
+
+    async def handle_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ):
+        try:
+            data = await reader.read(4096)
+            if not data:
+                return
+
+            request = DaemonRequest.model_validate_json(data.decode())
+
+            response = await self.process_command(request)
+            writer.write(response.model_dump_json().encode())
+            await writer.drain()
+        except Exception as e:
+            logger.error(f"Error handling client: {e}")
+            error_response = DaemonResponse(status="error", message=str(e))
+            writer.write(error_response.model_dump_json().encode())
+            await writer.drain()
+        finally:
+            writer.close()
+            await writer.wait_closed()
+
+    async def process_command(self, request: DaemonRequest) -> DaemonResponse:
+        params = request.params
+        match request.command:
+            case "create":
+                if not isinstance(params, CreateParams):
+                    return DaemonResponse(
+                        status="error", message="Invalid parameters for create"
+                    )
+                name = params.name
+                image = params.image
+
+                if name in self.servers:
+                    return DaemonResponse(
+                        status="error", message=f"Server {name} already exists"
+                    )
+
+                self.servers[name] = ServerInfo(image=image)
+                return DaemonResponse(
+                    status="success",
+                    message=f"Server {name} created with image {image}",
+                )
+
+            case "list":
+                return DaemonResponse(status="success", servers=self.servers)
+
+            case "stop":
+                if not isinstance(params, StopParams):
+                    return DaemonResponse(
+                        status="error", message="Invalid parameters for stop"
+                    )
+                name = params.name
+                if name not in self.servers:
+                    return DaemonResponse(
+                        status="error", message=f"Server {name} not found"
+                    )
+
+                del self.servers[name]
+                return DaemonResponse(
+                    status="success", message=f"Server {name} stopped"
+                )
+
+            case _:
+                return DaemonResponse(
+                    status="error", message=f"Unknown command: {request.command}"
+                )
+
+    async def run(self):
+        if SOCKET_PATH.exists():
+            SOCKET_PATH.unlink()
+
+        server = await asyncio.start_unix_server(
+            self.handle_client, path=str(SOCKET_PATH)
+        )
+        async with server:
+            await server.serve_forever()
+
+
+if __name__ == "__main__":
+    daemon = Daemon()
+    anyio.run(daemon.run)

src/lsp_client/cli/servers.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+import time
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from lsp_client.cli.daemon import (
+    SOCKET_PATH,
+    CreateParams,
+    DaemonRequest,
+    DaemonResponse,
+    ListParams,
+    StopParams,
+    start_daemon,
+)
+
+app = typer.Typer(help="Manage LSP servers")
+console = Console()
+
+
+def ensure_daemon():
+    """Ensure the daemon is running."""
+    if not SOCKET_PATH.exists():
+        start_daemon()
+        # Give it a moment to start
+        for _ in range(10):
+            if SOCKET_PATH.exists():
+                break
+            time.sleep(0.1)
+
+    # Try to connect to verify it's responsive
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.settimeout(1.0)
+            s.connect(str(SOCKET_PATH))
+    except (TimeoutError, ConnectionRefusedError):
+        if SOCKET_PATH.exists():
+            SOCKET_PATH.unlink()
+        start_daemon()
+        for _ in range(10):
+            if SOCKET_PATH.exists():
+                break
+            time.sleep(0.1)
+
+
+async def send_command(request: DaemonRequest) -> DaemonResponse:
+    """Send a command to the daemon and return the response."""
+    ensure_daemon()
+
+    reader, writer = await asyncio.open_unix_connection(str(SOCKET_PATH))
+    try:
+        writer.write(request.model_dump_json().encode())
+        await writer.drain()
+
+        data = await reader.read(4096)
+        if not data:
+            return DaemonResponse(status="error", message="No response from daemon")
+
+        return DaemonResponse.model_validate_json(data.decode())
+    finally:
+        writer.close()
+        await writer.wait_closed()
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Name of the server instance"),
+    image: str = typer.Argument(..., help="Docker image to use"),
+):
+    """Create a new LSP server instance."""
+    request = DaemonRequest(
+        command="create", params=CreateParams(name=name, image=image)
+    )
+    response = asyncio.run(send_command(request))
+    if response.status == "success":
+        console.print(f"[green]{response.message}[/green]")
+    else:
+        console.print(f"[red]Error: {response.message}[/red]")
+
+
+@app.command(name="list")
+def list_servers():
+    """List all running LSP server instances."""
+    request = DaemonRequest(command="list", params=ListParams())
+    response = asyncio.run(send_command(request))
+    if response.status == "success":
+        servers = response.servers or {}
+        if not servers:
+            console.print("No servers running.")
+            return
+
+        table = Table(title="LSP Servers")
+        table.add_column("Name", style="cyan")
+        table.add_column("Image", style="magenta")
+        table.add_column("Status", style="green")
+
+        for name, info in servers.items():
+            table.add_row(name, info.image, info.status)
+
+        console.print(table)
+    else:
+        console.print(f"[red]Error: {response.message}[/red]")
+
+
+@app.command()
+def stop(
+    name: str = typer.Argument(..., help="Name of the server instance to stop"),
+):
+    """Stop an LSP server instance."""
+    request = DaemonRequest(command="stop", params=StopParams(name=name))
+    response = asyncio.run(send_command(request))
+    if response.status == "success":
+        console.print(f"[green]{response.message}[/green]")
+    else:
+        console.print(f"[red]Error: {response.message}[/red]")
+
+
+if __name__ == "__main__":
+    app()