alysis-code 0.13.0__py3-none-any.whl

alysis_code/mcp/forge_scope.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ..config import ConfigError
+from .models import normalize_server_id
+
+
+@dataclass(frozen=True)
+class ForgeAllowedMcpTool:
+    server_id: str
+    tool_name: str
+
+    def as_payload(self) -> dict[str, str]:
+        return {
+            "server_id": self.server_id,
+            "tool_name": self.tool_name,
+        }
+
+
+@dataclass(frozen=True)
+class ForgeTaskMcpScope:
+    allow_resources: bool = False
+    allowed_tools: tuple[ForgeAllowedMcpTool, ...] = ()
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.allow_resources and not self.allowed_tools
+
+    def as_payload(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {}
+        if self.allow_resources:
+            payload["allow_resources"] = True
+        if self.allowed_tools:
+            payload["allowed_tools"] = [item.as_payload() for item in self.allowed_tools]
+        return payload
+
+
+def serialize_task_mcp_scope(scope: ForgeTaskMcpScope | None) -> dict[str, Any] | None:
+    if scope is None or scope.is_empty:
+        return None
+    return scope.as_payload()
+
+
+def describe_task_mcp_scope(scope: ForgeTaskMcpScope | None) -> str:
+    if scope is None or scope.is_empty:
+        return "disabled (default deny-by-default)"
+    parts = [
+        (
+            "generic MCP resources allowed"
+            if scope.allow_resources
+            else "generic MCP resources blocked"
+        ),
+        (
+            "allowed live MCP tools: "
+            + ", ".join(f"{item.server_id}/{item.tool_name}" for item in scope.allowed_tools)
+            if scope.allowed_tools
+            else "allowed live MCP tools: (none)"
+        ),
+    ]
+    return "; ".join(parts)
+
+
+def normalize_task_mcp_scope(
+    value: Any,
+    *,
+    warning_prefix: str,
+) -> tuple[ForgeTaskMcpScope | None, list[str]]:
+    if value is None:
+        return None, []
+
+    warnings: list[str] = []
+    if not isinstance(value, dict):
+        return None, [f"{warning_prefix}: dropped invalid mcp_scope: expected an object."]
+
+    allow_resources = False
+    if "allow_resources" in value:
+        raw_allow_resources = value.get("allow_resources")
+        if isinstance(raw_allow_resources, bool):
+            allow_resources = raw_allow_resources
+        else:
+            warnings.append(
+                f"{warning_prefix}: dropped invalid mcp_scope.allow_resources value; expected true/false."
+            )
+
+    allowed_tools: list[ForgeAllowedMcpTool] = []
+    seen_tool_keys: set[tuple[str, str]] = set()
+    if "allowed_tools" in value:
+        raw_allowed_tools = value.get("allowed_tools")
+        if not isinstance(raw_allowed_tools, list):
+            warnings.append(
+                f"{warning_prefix}: dropped invalid mcp_scope.allowed_tools value; expected an array."
+            )
+        else:
+            for index, raw_item in enumerate(raw_allowed_tools):
+                normalized_tool, tool_warnings = _normalize_allowed_tool_entry(
+                    raw_item,
+                    warning_prefix=warning_prefix,
+                    index=index,
+                )
+                warnings.extend(tool_warnings)
+                if normalized_tool is None:
+                    continue
+                dedupe_key = (
+                    normalized_tool.server_id,
+                    normalized_tool.tool_name.casefold(),
+                )
+                if dedupe_key in seen_tool_keys:
+                    continue
+                seen_tool_keys.add(dedupe_key)
+                allowed_tools.append(normalized_tool)
+
+    scope = ForgeTaskMcpScope(
+        allow_resources=allow_resources,
+        allowed_tools=tuple(allowed_tools),
+    )
+    if scope.is_empty:
+        warnings.append(
+            f"{warning_prefix}: normalized empty mcp_scope; MCP execution remains deny-by-default."
+        )
+        return None, warnings
+    return scope, warnings
+
+
+def _normalize_allowed_tool_entry(
+    raw_item: Any,
+    *,
+    warning_prefix: str,
+    index: int,
+) -> tuple[ForgeAllowedMcpTool | None, list[str]]:
+    item_label = f"{warning_prefix}: dropped invalid mcp_scope.allowed_tools[{index}] entry"
+    if not isinstance(raw_item, dict):
+        return None, [f"{item_label}: expected an object."]
+
+    raw_server_id = raw_item.get("server_id")
+    if not isinstance(raw_server_id, str):
+        return None, [f"{item_label}: server_id must be a string."]
+    server_id_value = raw_server_id.strip()
+    if not server_id_value:
+        return None, [f"{item_label}: server_id cannot be empty."]
+    try:
+        server_id = normalize_server_id(server_id_value)
+    except ConfigError as exc:
+        return None, [f"{item_label}: {exc}"]
+
+    raw_tool_name = raw_item.get("tool_name")
+    if not isinstance(raw_tool_name, str):
+        return None, [f"{item_label}: tool_name must be a string."]
+    tool_name = raw_tool_name.strip()
+    if not tool_name:
+        return None, [f"{item_label}: tool_name cannot be empty."]
+
+    return ForgeAllowedMcpTool(server_id=server_id, tool_name=tool_name), []

alysis_code/mcp/jsonrpc.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, TypeAlias
+
+from .errors import McpProtocolError
+
+JsonRpcId: TypeAlias = int | str
+
+
+class JsonRpcProtocolError(McpProtocolError):
+    pass
+
+
+def _validate_request_id(value: object, *, field_name: str = "id") -> JsonRpcId:
+    if isinstance(value, bool):
+        raise JsonRpcProtocolError(f"JSON-RPC {field_name} must be a string or integer.")
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str):
+        cleaned = value.strip()
+        if not cleaned:
+            raise JsonRpcProtocolError(f"JSON-RPC {field_name} cannot be empty.")
+        return cleaned
+    raise JsonRpcProtocolError(f"JSON-RPC {field_name} must be a string or integer.")
+
+
+def _validate_method(value: object) -> str:
+    if not isinstance(value, str):
+        raise JsonRpcProtocolError("JSON-RPC method must be a string.")
+    cleaned = value.strip()
+    if not cleaned:
+        raise JsonRpcProtocolError("JSON-RPC method cannot be empty.")
+    return cleaned
+
+
+def _validate_envelope_version(payload: dict[str, Any]) -> None:
+    if payload.get("jsonrpc") != "2.0":
+        raise JsonRpcProtocolError("JSON-RPC envelope must include jsonrpc='2.0'.")
+
+
+@dataclass(frozen=True)
+class JsonRpcErrorObject:
+    code: int
+    message: str
+    data: Any | None = None
+
+    @classmethod
+    def from_payload(cls, payload: object) -> JsonRpcErrorObject:
+        if not isinstance(payload, dict):
+            raise JsonRpcProtocolError("JSON-RPC error payload must be an object.")
+        code = payload.get("code")
+        message = payload.get("message")
+        if isinstance(code, bool) or not isinstance(code, int):
+            raise JsonRpcProtocolError("JSON-RPC error.code must be an integer.")
+        if not isinstance(message, str) or not message.strip():
+            raise JsonRpcProtocolError("JSON-RPC error.message must be a non-empty string.")
+        return cls(code=code, message=message.strip(), data=payload.get("data"))
+
+    def as_payload(self) -> dict[str, Any]:
+        payload = {
+            "code": self.code,
+            "message": self.message,
+        }
+        if self.data is not None:
+            payload["data"] = self.data
+        return payload
+
+
+@dataclass(frozen=True)
+class JsonRpcRequest:
+    id: JsonRpcId
+    method: str
+    params: Any | None = None
+
+
+@dataclass(frozen=True)
+class JsonRpcNotification:
+    method: str
+    params: Any | None = None
+
+
+@dataclass(frozen=True)
+class JsonRpcResponse:
+    id: JsonRpcId
+    result: Any | None = None
+    error: JsonRpcErrorObject | None = None
+
+
+JsonRpcMessage: TypeAlias = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse
+
+
+class JsonRpcIdGenerator:
+    def __init__(self, *, start: int = 1) -> None:
+        self._next_id = int(start)
+
+    def next(self) -> int:
+        request_id = self._next_id
+        self._next_id += 1
+        return request_id
+
+
+def encode_jsonrpc_message(payload: dict[str, Any]) -> str:
+    return json.dumps(payload, ensure_ascii=True, separators=(",", ":"))
+
+
+def build_jsonrpc_request(
+    *,
+    request_id: JsonRpcId,
+    method: str,
+    params: Any | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "jsonrpc": "2.0",
+        "id": _validate_request_id(request_id),
+        "method": _validate_method(method),
+    }
+    if params is not None:
+        payload["params"] = params
+    return payload
+
+
+def build_jsonrpc_notification(
+    *,
+    method: str,
+    params: Any | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "jsonrpc": "2.0",
+        "method": _validate_method(method),
+    }
+    if params is not None:
+        payload["params"] = params
+    return payload
+
+
+def build_jsonrpc_result_response(
+    *,
+    request_id: JsonRpcId,
+    result: Any,
+) -> dict[str, Any]:
+    return {
+        "jsonrpc": "2.0",
+        "id": _validate_request_id(request_id),
+        "result": result,
+    }
+
+
+def build_jsonrpc_error_response(
+    *,
+    request_id: JsonRpcId,
+    code: int,
+    message: str,
+    data: Any | None = None,
+) -> dict[str, Any]:
+    error = JsonRpcErrorObject(code=code, message=str(message).strip(), data=data)
+    return {
+        "jsonrpc": "2.0",
+        "id": _validate_request_id(request_id),
+        "error": error.as_payload(),
+    }
+
+
+def _parse_jsonrpc_message(payload: object) -> JsonRpcMessage:
+    if not isinstance(payload, dict):
+        raise JsonRpcProtocolError("JSON-RPC message must be an object.")
+    _validate_envelope_version(payload)
+
+    has_method = "method" in payload
+    has_id = "id" in payload
+    has_result = "result" in payload
+    has_error = "error" in payload
+
+    if has_method:
+        method = _validate_method(payload.get("method"))
+        if has_result or has_error:
+            raise JsonRpcProtocolError(
+                "JSON-RPC request/notification cannot include result or error fields."
+            )
+        params = payload.get("params")
+        if has_id:
+            return JsonRpcRequest(
+                id=_validate_request_id(payload.get("id")),
+                method=method,
+                params=params,
+            )
+        return JsonRpcNotification(method=method, params=params)
+
+    if not has_id:
+        raise JsonRpcProtocolError("JSON-RPC response must include an id field.")
+    if has_result == has_error:
+        raise JsonRpcProtocolError("JSON-RPC response must include exactly one of result or error.")
+    request_id = _validate_request_id(payload.get("id"))
+    if has_error:
+        return JsonRpcResponse(
+            id=request_id, error=JsonRpcErrorObject.from_payload(payload["error"])
+        )
+    return JsonRpcResponse(id=request_id, result=payload.get("result"))
+
+
+def parse_jsonrpc_line(raw_line: str) -> tuple[JsonRpcMessage, ...]:
+    text = str(raw_line).strip()
+    if not text:
+        raise JsonRpcProtocolError("JSON-RPC line cannot be empty.")
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise JsonRpcProtocolError(f"Malformed JSON-RPC JSON: {exc.msg}") from exc
+    if isinstance(payload, list):
+        if not payload:
+            raise JsonRpcProtocolError("JSON-RPC batch payload cannot be empty.")
+        return tuple(_parse_jsonrpc_message(item) for item in payload)
+    return (_parse_jsonrpc_message(payload),)