agentpool 2.1.9__py3-none-any.whl → 2.2.3__py3-none-any.whl

agentpool_server/opencode_server/routes/global_routes.py

@@ -0,0 +1,94 @@
+"""Global routes (health, events)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter
+from sse_starlette.sse import EventSourceResponse
+
+from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.models import (  # noqa: TC001
+    Event,
+    HealthResponse,
+    ServerConnectedEvent,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from agentpool_server.opencode_server.state import ServerState
+
+
+logger = logging.getLogger(__name__)
+router = APIRouter(tags=["global"])
+
+VERSION = "0.1.0"
+
+
+@router.get("/global/health")
+async def get_health() -> HealthResponse:
+    """Get server health status."""
+    return HealthResponse(healthy=True, version=VERSION)
+
+
+def _serialize_event(event: Event, wrap_payload: bool = False) -> str:
+    """Serialize event, optionally wrapping in payload structure."""
+    import json
+
+    event_data = event.model_dump(by_alias=True, exclude_none=True)
+    if wrap_payload:
+        return json.dumps({"payload": event_data})
+    return json.dumps(event_data)
+
+
+async def _event_generator(
+    state: ServerState, *, wrap_payload: bool = False
+) -> AsyncGenerator[dict[str, Any]]:
+    """Generate SSE events."""
+    queue: asyncio.Queue[Event] = asyncio.Queue()
+    state.event_subscribers.append(queue)
+    subscriber_count = len(state.event_subscribers)
+    logger.info("SSE: New client connected (total subscribers: %s)", subscriber_count)
+
+    # Trigger first subscriber callback if this is the first connection
+    if (
+        subscriber_count == 1
+        and not state._first_subscriber_triggered
+        and state.on_first_subscriber is not None
+    ):
+        state._first_subscriber_triggered = True
+        state.create_background_task(state.on_first_subscriber(), name="on_first_subscriber")
+
+    try:
+        # Send initial connected event
+        connected = ServerConnectedEvent()
+        data = _serialize_event(connected, wrap_payload=wrap_payload)
+        logger.info("SSE: Sending connected event: %s", data)
+        yield {"data": data}
+        # Stream events
+        while True:
+            event = await queue.get()
+            data = _serialize_event(event, wrap_payload=wrap_payload)
+            logger.info("SSE: Sending event: %s", event.type)
+            yield {"data": data}
+    finally:
+        state.event_subscribers.remove(queue)
+        logger.info(
+            "SSE: Client disconnected (remaining subscribers: %s)", len(state.event_subscribers)
+        )
+
+
+@router.get("/global/event")
+async def get_global_events(state: StateDep) -> EventSourceResponse:
+    """Get global events as SSE stream (uses payload wrapper)."""
+    return EventSourceResponse(_event_generator(state, wrap_payload=True), sep="\n")
+
+
+@router.get("/event")
+async def get_events(state: StateDep) -> EventSourceResponse:
+    """Get events as SSE stream (no payload wrapper)."""
+    return EventSourceResponse(_event_generator(state, wrap_payload=False), sep="\n")

agentpool_server/opencode_server/routes/lsp_routes.py

@@ -0,0 +1,319 @@
+"""LSP (Language Server Protocol) routes.
+
+Provides endpoints for LSP server status and diagnostics,
+compatible with OpenCode's LSP API.
+"""
+
+from __future__ import annotations
+
+from contextlib import suppress
+import os
+from typing import Literal
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from agentpool_server.opencode_server.dependencies import StateDep  # noqa: TC001
+from agentpool_server.opencode_server.models.events import LspStatus, LspUpdatedEvent
+
+
+# =============================================================================
+# Diagnostic Models (matching OpenCode's LSP diagnostic format)
+# =============================================================================
+
+
+class DiagnosticPosition(BaseModel):
+    """Position in a text document."""
+
+    line: int
+    character: int
+
+
+class DiagnosticRange(BaseModel):
+    """Range in a text document."""
+
+    start: DiagnosticPosition
+    end: DiagnosticPosition
+
+
+class Diagnostic(BaseModel):
+    """LSP Diagnostic matching vscode-languageserver-types format."""
+
+    range: DiagnosticRange
+    message: str
+    severity: int | None = None  # 1=Error, 2=Warning, 3=Info, 4=Hint
+    code: str | int | None = None
+    source: str | None = None
+
+
+class FormatterStatus(BaseModel):
+    """Formatter status information."""
+
+    id: str
+    """Formatter identifier."""
+
+    name: str
+    """Formatter name."""
+
+    root: str
+    """Workspace root path."""
+
+    status: Literal["connected", "error"]
+    """Connection status."""
+
+
+router = APIRouter(tags=["lsp"])
+
+
+@router.get("/lsp")
+async def list_lsp_servers(state: StateDep) -> list[LspStatus]:
+    """List all active LSP servers.
+
+    Returns the status of all running LSP servers, including their
+    connection state and workspace root.
+
+    Returns:
+        List of LSP server status objects.
+    """
+    try:
+        lsp_manager = state.get_or_create_lsp_manager()
+    except RuntimeError:
+        # Agent doesn't have an execution environment - return empty list
+        return []
+
+    servers: list[LspStatus] = []
+    for server_id, server_state in lsp_manager._servers.items():
+        # Get relative root path
+        root_uri = server_state.root_uri or ""
+        if root_uri.startswith("file://"):
+            root_path = root_uri[7:]  # Remove file:// prefix
+            # Make path relative to working directory
+            with suppress(ValueError):
+                root_path = os.path.relpath(root_path, state.working_dir)
+        else:
+            root_path = root_uri
+
+        servers.append(
+            LspStatus(
+                id=server_id,
+                name=server_id,
+                root=root_path,
+                status="connected" if server_state.initialized else "error",
+            )
+        )
+
+    return servers
+
+
+@router.post("/lsp/start")
+async def start_lsp_server(
+    state: StateDep,
+    server_id: str = Query(..., description="LSP server ID (e.g., 'pyright', 'rust-analyzer')"),
+    root_uri: str | None = Query(None, description="Workspace root URI"),
+) -> LspStatus:
+    """Start an LSP server.
+
+    Starts the specified LSP server for the given workspace root.
+    If no root_uri is provided, uses the server's working directory.
+
+    Args:
+        state: Server state dependency (injected).
+        server_id: The LSP server identifier (e.g., 'pyright', 'typescript').
+        root_uri: Optional workspace root URI (file:// format).
+
+    Returns:
+        The started server's status.
+
+    Raises:
+        HTTPException: If the server fails to start or is not registered.
+    """
+    try:
+        lsp_manager = state.get_or_create_lsp_manager()
+    except RuntimeError as e:
+        raise HTTPException(status_code=503, detail=str(e)) from e
+
+    # Default to working directory if no root provided
+    if root_uri is None:
+        root_uri = f"file://{state.working_dir}"
+
+    try:
+        server_state = await lsp_manager.start_server(server_id, root_uri)
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e)) from e
+    except RuntimeError as e:
+        raise HTTPException(status_code=500, detail=str(e)) from e
+
+    # Emit lsp.updated event to notify clients of server status change
+    await state.broadcast_event(LspUpdatedEvent.create())
+
+    # Get relative root path for response
+    root_path = root_uri
+    if root_uri.startswith("file://"):
+        root_path = root_uri[7:]
+        with suppress(ValueError):
+            root_path = os.path.relpath(root_path, state.working_dir)
+
+    return LspStatus(
+        id=server_id,
+        name=server_id,
+        root=root_path,
+        status="connected" if server_state.initialized else "error",
+    )
+
+
+@router.post("/lsp/stop")
+async def stop_lsp_server(
+    state: StateDep,
+    server_id: str = Query(..., description="LSP server ID to stop"),
+) -> dict[str, str]:
+    """Stop an LSP server.
+
+    Args:
+        state: Server state dependency (injected).
+        server_id: The LSP server identifier to stop.
+
+    Returns:
+        Success message.
+    """
+    try:
+        lsp_manager = state.get_or_create_lsp_manager()
+    except RuntimeError:
+        return {"status": "ok", "message": "No LSP manager active"}
+
+    await lsp_manager.stop_server(server_id)
+
+    # Emit lsp.updated event to notify clients of server status change
+    await state.broadcast_event(LspUpdatedEvent.create())
+
+    return {"status": "ok", "message": f"Server {server_id} stopped"}
+
+
+@router.get("/lsp/diagnostics")
+async def get_diagnostics(
+    state: StateDep,
+    path: str | None = Query(None, description="File path to get diagnostics for"),
+) -> dict[str, list[Diagnostic]]:
+    """Get diagnostics from all active LSP servers.
+
+    Returns diagnostics organized by file path. If a specific path is provided,
+    returns diagnostics only for that file using CLI diagnostics.
+
+    This uses CLI-based diagnostic tools (pyright, mypy, etc.) which are more
+    reliable for on-demand checks than the LSP push model.
+
+    Args:
+        state: Server state dependency (injected).
+        path: Optional file path to get diagnostics for.
+
+    Returns:
+        Dictionary mapping file paths to lists of diagnostic objects.
+    """
+    try:
+        lsp_manager = state.get_or_create_lsp_manager()
+    except RuntimeError:
+        return {}
+
+    results: dict[str, list[Diagnostic]] = {}
+
+    # If a specific path is provided, run CLI diagnostics for it
+    if path:
+        # Make path absolute if needed
+        if not os.path.isabs(path):  # noqa: PTH117
+            path = os.path.join(state.working_dir, path)  # noqa: PTH118
+
+        # Find the appropriate server for this file
+        server_info = lsp_manager.get_server_for_file(path)
+        if server_info and server_info.has_cli_diagnostics:
+            try:
+                result = await lsp_manager.run_cli_diagnostics(server_info.id, [path])
+                if result.success and result.diagnostics:
+                    for diag in result.diagnostics:
+                        file_path = diag.file or path
+                        if file_path not in results:
+                            results[file_path] = []
+                        # Convert from 1-based (CLI tools) to 0-based (LSP)
+                        results[file_path].append(
+                            Diagnostic(
+                                range=DiagnosticRange(
+                                    start=DiagnosticPosition(
+                                        line=max(0, diag.line - 1),
+                                        character=max(0, diag.column - 1),
+                                    ),
+                                    end=DiagnosticPosition(
+                                        line=max(0, (diag.end_line or diag.line) - 1),
+                                        character=max(0, (diag.end_column or diag.column) - 1),
+                                    ),
+                                ),
+                                message=diag.message,
+                                severity=_severity_to_lsp(diag.severity),
+                                code=diag.code,
+                                source=diag.source or server_info.id,
+                            )
+                        )
+            except Exception:  # noqa: BLE001
+                # CLI diagnostics failed, return empty
+                pass
+
+    return results
+
+
+def _severity_to_lsp(severity: str) -> int:
+    """Convert severity string to LSP severity number."""
+    mapping = {
+        "error": 1,
+        "warning": 2,
+        "info": 3,
+        "hint": 4,
+    }
+    return mapping.get(severity.lower(), 1)
+
+
+@router.get("/lsp/servers")
+async def list_available_servers(state: StateDep) -> list[dict[str, object]]:
+    """List all registered (available) LSP servers.
+
+    Returns information about all LSP servers that can be started,
+    regardless of whether they are currently running.
+
+    Returns:
+        List of server configurations.
+    """
+    try:
+        lsp_manager = state.get_or_create_lsp_manager()
+    except RuntimeError:
+        return []
+
+    servers = []
+    for server_id, config in lsp_manager._server_configs.items():
+        servers.append({
+            "id": server_id,
+            "extensions": config.extensions,
+            "running": server_id in lsp_manager._servers,
+        })
+
+    return servers
+
+
+# =============================================================================
+# Formatter Routes
+# =============================================================================
+
+
+@router.get("/formatter")
+async def list_formatters(state: StateDep) -> list[FormatterStatus]:
+    """List all active formatters.
+
+    Returns the status of all running formatters, including their
+    connection state and workspace root.
+
+    Note: This is currently a stub that returns an empty list.
+    Formatter support can be added in the future.
+
+    Returns:
+        List of formatter status objects.
+    """
+    # Stub implementation - formatters not yet implemented
+    # OpenCode has formatters like prettier, biome, etc.
+    # For now, return empty list
+    _ = state  # Reserved for future use
+    return []