fenix-mcp 0.1.0__py3-none-any.whl

fenix_mcp/infrastructure/http_client.py

@@ -0,0 +1,84 @@
+# SPDX-License-Identifier: MIT
+"""HTTP client with retries and simple instrumentation."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, Mapping, Optional
+
+import requests
+from requests import Response, Session
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+@dataclass(slots=True)
+class HttpClient:
+    """Simple synchronous HTTP client used by the API layer."""
+
+    base_url: str
+    timeout: float = 30.0
+    default_headers: Optional[Mapping[str, str]] = None
+    _logger: logging.Logger = field(init=False, repr=False)
+    _session: Session = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "_logger", logging.getLogger("fenix_mcp.http"))
+        object.__setattr__(self, "_session", self._build_session())
+
+    def _build_session(self) -> Session:
+        session = requests.Session()
+        retry = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=("GET", "POST", "PATCH", "DELETE", "PUT"),
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        return session
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        *,
+        json: Optional[Mapping[str, Any]] = None,
+        params: Optional[Mapping[str, Any]] = None,
+        headers: Optional[Mapping[str, str]] = None,
+    ) -> Response:
+        url = f"{self.base_url}{endpoint}"
+        merged_headers = dict(self.default_headers or {})
+        merged_headers.update(headers or {})
+
+        self._logger.debug(
+            "HTTP request",
+            extra={
+                "method": method,
+                "url": url,
+                "params": params,
+                "has_body": json is not None,
+            },
+        )
+
+        response = self._session.request(
+            method=method.upper(),
+            url=url,
+            json=json,
+            params=params,
+            headers=merged_headers,
+            timeout=self.timeout,
+        )
+
+        self._logger.debug(
+            "HTTP response",
+            extra={
+                "status": response.status_code,
+                "url": url,
+                "request_id": response.headers.get("x-request-id"),
+            },
+        )
+
+        return response

fenix_mcp/infrastructure/logging.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MIT
+"""Logging configuration utilities."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any, Dict
+
+
+class _SensitiveFormatter(logging.Formatter):
+    """Formatter that removes obvious tokens from logs."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        if isinstance(record.args, dict):
+            record.args = self._sanitize_dict(record.args)
+        elif isinstance(record.args, tuple):
+            record.args = tuple(self._sanitize(value) for value in record.args)
+        return super().format(record)
+
+    def _sanitize_dict(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return {key: self._sanitize(value) for key, value in data.items()}
+
+    def _sanitize(self, value: Any) -> Any:
+        if isinstance(value, str) and "pat_" in value:
+            return value[:10] + "…" + value[-4:]
+        return value
+
+
+def configure_logging(level: str = "INFO") -> None:
+    """Configure root logger with a basic structured format."""
+
+    handler = logging.StreamHandler(sys.stderr)
+    formatter = _SensitiveFormatter(
+        fmt="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    handler.setFormatter(formatter)
+
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.setLevel(level)
+    root.addHandler(handler)

fenix_mcp/interface/mcp_server.py

@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: MIT
+"""Lightweight MCP server implementation backed by the tool registry."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+import uuid
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from fenix_mcp.application.tool_registry import ToolRegistry, build_default_registry
+from fenix_mcp.infrastructure.context import AppContext
+
+
+class McpServerError(RuntimeError):
+    pass
+
+
+@dataclass(slots=True)
+class SimpleMcpServer:
+    context: AppContext
+    registry: ToolRegistry
+    session_id: str
+
+    def set_personal_access_token(self, token: Optional[str]) -> None:
+        self.context.api_client.update_token(token)
+
+    async def handle(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        method = request.get("method")
+        request_id = request.get("id")
+
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}, "logging": {}},
+                    "serverInfo": {"name": "fenix_cloud_mcp_py", "version": "0.1.0"},
+                    "sessionId": self.session_id,
+                },
+            }
+
+        if method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {"tools": self.registry.list_definitions()},
+            }
+
+        if method == "tools/call":
+            params = request.get("params") or {}
+            name = params.get("name")
+            arguments = params.get("arguments") or {}
+
+            if not name:
+                raise McpServerError("Missing tool name in tools/call payload")
+
+            result = await self.registry.execute(name, arguments, self.context)
+
+            return {"jsonrpc": "2.0", "id": request_id, "result": result}
+
+        if method == "notifications/initialized":
+            # Notifications do not require a response
+            return None
+
+        raise McpServerError(f"Unsupported method: {method}")
+
+
+def build_server(context: AppContext) -> SimpleMcpServer:
+    registry = build_default_registry(context)
+    return SimpleMcpServer(
+        context=context,
+        registry=registry,
+        session_id=str(uuid.uuid4()),
+    )

fenix_mcp/interface/transports.py

@@ -0,0 +1,227 @@
+# SPDX-License-Identifier: MIT
+"""Transport management supporting STDIO and HTTP JSON-RPC."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import sys
+import contextlib
+from contextlib import AsyncExitStack
+from typing import Iterable, List, Protocol
+
+from aiohttp import web
+
+from fenix_mcp.infrastructure.config import Settings
+
+
+class Transport(Protocol):
+    name: str
+
+    async def serve_forever(self) -> None:
+        ...
+
+
+class StdIoTransport:
+    name = "stdio"
+
+    def __init__(self, server):
+        self._server = server
+        self._logger = logging.getLogger("fenix_mcp.transport.stdio")
+
+    async def serve_forever(self) -> None:
+        loop = asyncio.get_running_loop()
+        self._logger.info("STDIO transport awaiting input")
+        try:
+            while True:
+                line = await loop.run_in_executor(None, sys.stdin.readline)
+                if not line:
+                    await asyncio.sleep(0.05)
+                    continue
+
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    request = json.loads(line)
+                except json.JSONDecodeError as exc:  # pragma: no cover - defensive
+                    self._logger.warning("Invalid JSON received on STDIO", extra={"error": str(exc)})
+                    continue
+
+                try:
+                    response = await self._server.handle(request)
+                except Exception as exc:  # pragma: no cover - defensive
+                    self._logger.exception("STDIO transport error")
+                    response = {
+                        "jsonrpc": "2.0",
+                        "id": request.get("id") if isinstance(request, dict) else None,
+                        "error": {"code": -32000, "message": str(exc)},
+                    }
+
+                if response is not None:
+                    sys.stdout.write(json.dumps(response) + "\n")
+                    sys.stdout.flush()
+        except asyncio.CancelledError:  # pragma: no cover - cancellation path
+            self._logger.debug("STDIO transport cancelled")
+
+
+class HttpTransport:
+    name = "http"
+
+    def __init__(self, server, host: str, port: int):
+        self._server = server
+        self._host = host
+        self._port = port
+        self._logger = logging.getLogger("fenix_mcp.transport.http")
+        self._runner: web.AppRunner | None = None
+        self._shutdown_event = asyncio.Event()
+
+    async def serve_forever(self) -> None:
+        await self._start()
+        try:
+            await self._shutdown_event.wait()
+        except asyncio.CancelledError:  # pragma: no cover - cancellation path
+            self._logger.debug("HTTP transport cancelled")
+        finally:
+            await self._cleanup()
+
+    async def shutdown(self) -> None:
+        self._shutdown_event.set()
+        await self._cleanup()
+
+    async def _start(self) -> None:
+        if self._runner is not None:
+            return
+
+        app = web.Application()
+        app.add_routes(
+            [
+                web.get("/health", self._handle_health),
+                web.post("/jsonrpc", self._handle_jsonrpc),
+                web.options("/jsonrpc", self._handle_options),
+            ]
+        )
+
+        runner = web.AppRunner(app)
+        await runner.setup()
+        site = web.TCPSite(runner, host=self._host, port=self._port)
+        try:
+            await site.start()
+        except Exception as exc:  # pragma: no cover - defensive
+            self._logger.exception(
+                "Failed to bind HTTP transport",
+                extra={"host": self._host, "port": self._port},
+            )
+            raise
+
+        self._logger.info("HTTP transport listening", extra={"host": self._host, "port": self._port})
+        self._runner = runner
+
+    async def _cleanup(self) -> None:
+        runner, self._runner = self._runner, None
+        if runner is not None:
+            await runner.cleanup()
+
+    def _with_cors(self, response: web.StreamResponse) -> web.StreamResponse:
+        response.headers.setdefault("Access-Control-Allow-Origin", "*")
+        response.headers.setdefault("Access-Control-Allow-Headers", "Content-Type, Authorization")
+        response.headers.setdefault("Access-Control-Allow-Methods", "POST, OPTIONS")
+        return response
+
+    async def _handle_health(self, request: web.Request) -> web.Response:
+        payload = {
+            "status": "ok",
+            "transport": "http",
+            "sessionId": self._server.session_id,
+        }
+        return self._with_cors(web.json_response(payload))
+
+    async def _handle_options(self, request: web.Request) -> web.StreamResponse:
+        return self._with_cors(web.Response(status=204))
+
+    async def _handle_jsonrpc(self, request: web.Request) -> web.StreamResponse:
+        auth_header = request.headers.get('Authorization') or request.headers.get('authorization')
+        if auth_header and auth_header.lower().startswith('bearer '):
+            token = auth_header.split(' ', 1)[1].strip()
+            if token:
+                self._server.set_personal_access_token(token)
+
+        try:
+            payload = await request.json()
+        except Exception:  # pragma: no cover - defensive
+            return self._with_cors(
+                web.json_response(
+                    {"error": {"code": -32700, "message": "Invalid JSON"}}, status=400
+                )
+            )
+
+        self._logger.debug("JSON-RPC request payload", extra={"payload": payload})
+
+        try:
+            response = await self._server.handle(payload)
+        except Exception as exc:  # pragma: no cover - defensive
+            self._logger.exception("Error processing JSON-RPC request")
+            return self._with_cors(
+                web.json_response(
+                    {"error": {"code": -32000, "message": str(exc)}}, status=500
+                )
+            )
+
+        if response is None:
+            return self._with_cors(web.Response(status=204))
+        return self._with_cors(web.json_response(response))
+
+
+class CompositeTransport:
+    def __init__(self, transports: Iterable[Transport]):
+        self._transports: List[Transport] = list(transports)
+        self.name = "+".join(transport.name for transport in self._transports)
+
+    async def serve_forever(self) -> None:
+        tasks = [asyncio.create_task(t.serve_forever()) for t in self._transports]
+        try:
+            await asyncio.gather(*tasks)
+        finally:
+            for task in tasks:
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+
+class TransportFactory:
+    def __init__(self, settings: Settings, logger: logging.Logger | None = None):
+        self._settings = settings
+        self._logger = logger or logging.getLogger("fenix_mcp.transport")
+
+    async def create(self, *, stack: AsyncExitStack, server) -> Transport:
+        transports: List[Transport] = []
+
+        if self._settings.transport_mode in ("stdio", "both"):
+            self._logger.info("Enabling STDIO transport")
+            transports.append(StdIoTransport(server))
+
+        if self._settings.transport_mode in ("http", "both"):
+            self._logger.info(
+                "Enabling HTTP transport",
+                extra={
+                    "host": self._settings.http_host,
+                    "port": self._settings.http_port,
+                },
+            )
+            http_transport = HttpTransport(
+                server,
+                host=self._settings.http_host,
+                port=self._settings.http_port,
+            )
+            stack.push_async_callback(http_transport.shutdown)
+            transports.append(http_transport)
+
+        if not transports:
+            raise ValueError("No transport configured. Check FENIX_TRANSPORT_MODE env var.")
+
+        if len(transports) == 1:
+            return transports[0]
+
+        return CompositeTransport(transports)

fenix_mcp/main.py

@@ -0,0 +1,90 @@
+# SPDX-License-Identifier: MIT
+"""CLI entry point for the Fênix MCP server."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import os
+from contextlib import AsyncExitStack
+
+from fenix_mcp.infrastructure.config import Settings, load_settings
+from fenix_mcp.infrastructure.context import AppContext
+from fenix_mcp.infrastructure.logging import configure_logging
+from fenix_mcp.infrastructure.fenix_api.client import FenixApiClient
+from fenix_mcp.interface.mcp_server import build_server
+from fenix_mcp.interface.transports import TransportFactory
+
+def _normalize_pat(token: str | None) -> str | None:
+    if token is None:
+        return None
+    value = token.strip()
+    if value.lower().startswith("bearer "):
+        value = value[7:].strip()
+    return value or None
+
+
+async def _run_async(pat_token: str | None) -> None:
+    """Async bootstrap so we can support both STDIO and HTTP/SSE transports."""
+
+    settings: Settings = load_settings()
+    configure_logging(level=settings.log_level)
+
+    logger = logging.getLogger("fenix_mcp.main")
+    settings_payload = settings.model_dump(mode="python")
+    settings_payload["api_url"] = str(settings.api_url)
+    logger.info(
+        "Loaded configuration: transport=%s api_url=%s http=%s:%s",
+        settings.transport_mode,
+        settings_payload["api_url"],
+        settings.http_host,
+        settings.http_port,
+    )
+
+    token = _normalize_pat(pat_token) or _normalize_pat(os.getenv("FENIX_PAT_TOKEN"))
+
+    if token:
+        logger.debug("Using PAT token (length=%s)", len(token))
+    else:
+        logger.debug("No PAT token provided; relying on Authorization headers")
+
+    api_client = FenixApiClient(
+        base_url=str(settings.api_url),
+        personal_access_token=token,
+        timeout=settings.http_timeout,
+    )
+
+    context = AppContext(
+        settings=settings,
+        logger=logging.getLogger("fenix_mcp"),
+        api_client=api_client,
+    )
+
+    async with AsyncExitStack() as stack:
+        server = build_server(context=context)
+        transport = await TransportFactory(settings, logger=logger).create(stack=stack, server=server)
+        logger.info("Fênix MCP server started (mode=%s)", transport.name)
+        await transport.serve_forever()
+
+
+def run() -> None:
+    """Entry point used by scripts."""
+
+    parser = argparse.ArgumentParser(description="Fênix MCP server")
+    parser.add_argument(
+        "--pat",
+        dest="pat_token",
+        default=None,
+        help="Personal Access Token for the Fênix API (with or without 'Bearer ').",
+    )
+    args = parser.parse_args()
+
+    try:
+        asyncio.run(_run_async(args.pat_token))
+    except KeyboardInterrupt:
+        logging.getLogger("fenix_mcp.main").info("Fênix MCP server interrupted by user")
+
+
+if __name__ == "__main__":
+    run()