mycode-coding-agent 0.1.0__py3-none-any.whl

mycode/mcp/__init__.py

@@ -0,0 +1,41 @@
+from mycode.mcp.config import (
+    MCPConfig,
+    MCPConfigError,
+    MCPLoadedConfig,
+    load_mcp_config,
+    load_mcp_config_layers,
+)
+from mycode.mcp.errors import safe_error_summary
+from mycode.mcp.manager import MCPManager
+from mycode.mcp.models import MCPServerStatus, MCPShutdownStatus
+from mycode.mcp.tool_adapter import MCPToolAdapter, build_registry_name
+from mycode.mcp.trust import (
+    MCPTrustConfirmer,
+    MCPTrustRequest,
+    MCPTrustResolution,
+    MCPTrustServer,
+    MCPTrustWarning,
+    apply_project_mcp_trust,
+    resolve_project_mcp_trust,
+)
+
+__all__ = [
+    "MCPConfig",
+    "MCPConfigError",
+    "MCPLoadedConfig",
+    "MCPManager",
+    "MCPServerStatus",
+    "MCPShutdownStatus",
+    "MCPToolAdapter",
+    "MCPTrustConfirmer",
+    "MCPTrustRequest",
+    "MCPTrustResolution",
+    "MCPTrustServer",
+    "MCPTrustWarning",
+    "apply_project_mcp_trust",
+    "build_registry_name",
+    "load_mcp_config",
+    "load_mcp_config_layers",
+    "resolve_project_mcp_trust",
+    "safe_error_summary",
+]

mycode/mcp/client.py

@@ -0,0 +1,44 @@
+from collections.abc import AsyncIterator
+from contextlib import AsyncExitStack, asynccontextmanager
+
+import httpx2
+from mcp import Client, StdioServerParameters
+from mcp.client.streamable_http import streamable_http_client
+
+from mycode.mcp.config import MCPServerConfig
+
+
+@asynccontextmanager
+async def open_mcp_client(config: MCPServerConfig) -> AsyncIterator[Client]:
+    async with AsyncExitStack() as stack:
+        if config.transport == "stdio":
+            client = Client(
+                StdioServerParameters(
+                    command=config.command,
+                    args=config.args,
+                    env=config.env or None,
+                ),
+                read_timeout_seconds=config.tool_timeout,
+            )
+        else:
+            http_client = await stack.enter_async_context(
+                httpx2.AsyncClient(
+                    headers=config.headers,
+                    event_hooks={"response": [_raise_auth_status]},
+                    follow_redirects=True,
+                    timeout=config.tool_timeout,
+                )
+            )
+            transport = streamable_http_client(
+                config.url,
+                http_client=http_client,
+                terminate_on_close=False,
+            )
+            client = Client(transport, read_timeout_seconds=config.tool_timeout)
+        yield await stack.enter_async_context(client)
+
+
+async def _raise_auth_status(response: httpx2.Response) -> None:
+    """Preserve 401/403 status without reading or exposing response content."""
+    if response.status_code in (401, 403):
+        response.raise_for_status()

mycode/mcp/config.py

@@ -0,0 +1,207 @@
+import json
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Annotated, Literal
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationError,
+    ValidationInfo,
+    field_validator,
+)
+
+from mycode.config import (
+    MYCODE_CONFIG_DIR_NAME,
+    load_layered_environment,
+)
+
+DEFAULT_MCP_CONFIG_FILE = "mcp.json"
+DEFAULT_MCP_CONNECT_TIMEOUT_SECONDS = 10.0
+DEFAULT_MCP_TOOL_TIMEOUT_SECONDS = 60.0
+DEFAULT_MCP_SHUTDOWN_TIMEOUT_SECONDS = 10.0
+_ALIAS_PATTERN = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+_ENV_PATTERN = re.compile(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}")
+
+
+class MCPConfigError(ValueError):
+    pass
+
+
+class _ServerBase(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    connect_timeout: float = Field(
+        default=DEFAULT_MCP_CONNECT_TIMEOUT_SECONDS, gt=0
+    )
+    tool_timeout: float = Field(default=DEFAULT_MCP_TOOL_TIMEOUT_SECONDS, gt=0)
+
+
+class MCPStdioServerConfig(_ServerBase):
+    transport: Literal["stdio"]
+    command: str = Field(min_length=1)
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, str] = Field(default_factory=dict, repr=False)
+
+    @field_validator("command")
+    @classmethod
+    def _non_blank_command(cls, value: str) -> str:
+        if value.strip() == "":
+            raise ValueError("command must not be blank")
+        return value
+
+
+class MCPStreamableHTTPServerConfig(_ServerBase):
+    transport: Literal["streamable_http"]
+    url: str = Field(min_length=1)
+    headers: dict[str, str] = Field(default_factory=dict, repr=False)
+
+    @field_validator("url")
+    @classmethod
+    def _http_url(cls, value: str, info: ValidationInfo) -> str:
+        allow_templates = bool(
+            info.context and info.context.get("allow_secret_templates")
+        )
+        if not value.startswith(("http://", "https://")) and not (
+            allow_templates and _ENV_PATTERN.search(value)
+        ):
+            raise ValueError("url must use http or https")
+        return value
+
+
+MCPServerConfig = Annotated[
+    MCPStdioServerConfig | MCPStreamableHTTPServerConfig,
+    Field(discriminator="transport"),
+]
+
+
+class MCPConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+    mcp_servers: dict[str, MCPServerConfig] = Field(
+        default_factory=dict, alias="mcpServers"
+    )
+
+    @field_validator("mcp_servers")
+    @classmethod
+    def _valid_aliases(
+        cls, value: dict[str, MCPServerConfig]
+    ) -> dict[str, MCPServerConfig]:
+        invalid = [alias for alias in value if _ALIAS_PATTERN.fullmatch(alias) is None]
+        if invalid:
+            raise ValueError("server aliases must match [A-Za-z0-9_-]{1,64}")
+        return value
+
+
+@dataclass(frozen=True)
+class MCPLoadedConfig:
+    """Resolved MCP layers plus the unresolved project layer used for trust."""
+
+    user: MCPConfig = field(repr=False)
+    project: MCPConfig = field(repr=False)
+    merged: MCPConfig = field(repr=False)
+    project_unresolved: MCPConfig = field(repr=False)
+
+
+def default_mcp_config_file() -> Path:
+    return Path.home() / MYCODE_CONFIG_DIR_NAME / DEFAULT_MCP_CONFIG_FILE
+
+
+def project_mcp_config_file(workspace_root: str | Path) -> Path:
+    return Path(workspace_root) / MYCODE_CONFIG_DIR_NAME / DEFAULT_MCP_CONFIG_FILE
+
+
+def load_mcp_config(
+    config_file: str | Path | None = None,
+    *,
+    env_file: str | Path | None = None,
+    environ: Mapping[str, str] | None = None,
+    workspace_root: str | Path | None = None,
+) -> MCPConfig:
+    return load_mcp_config_layers(
+        config_file,
+        env_file=env_file,
+        environ=environ,
+        workspace_root=workspace_root,
+    ).merged
+
+
+def load_mcp_config_layers(
+    config_file: str | Path | None = None,
+    *,
+    env_file: str | Path | None = None,
+    environ: Mapping[str, str] | None = None,
+    workspace_root: str | Path | None = None,
+) -> MCPLoadedConfig:
+    user_path = default_mcp_config_file() if config_file is None else Path(config_file)
+    user_config = _load_mcp_config_file(user_path)
+    project_config = (
+        MCPConfig()
+        if workspace_root is None
+        else _load_mcp_config_file(project_mcp_config_file(workspace_root))
+    )
+    environment = load_layered_environment(
+        env_file,
+        workspace_root=workspace_root,
+        environ=environ,
+    )
+    resolved_user_config = _resolve_config_secrets(user_config, environment)
+    resolved_project_config = _resolve_config_secrets(project_config, environment)
+    return MCPLoadedConfig(
+        user=resolved_user_config,
+        project=resolved_project_config,
+        merged=merge_mcp_configs(resolved_user_config, resolved_project_config),
+        project_unresolved=project_config,
+    )
+
+
+def merge_mcp_configs(user: MCPConfig, project: MCPConfig) -> MCPConfig:
+    return MCPConfig(
+        mcpServers={**user.mcp_servers, **project.mcp_servers}
+    )
+
+
+def _resolve_config_secrets(
+    config: MCPConfig,
+    environment: Mapping[str, str],
+) -> MCPConfig:
+    resolved = _resolve_secrets(config.model_dump(by_alias=True), environment)
+    try:
+        return MCPConfig.model_validate(resolved)
+    except ValidationError as error:
+        raise MCPConfigError("Invalid MCP config: validation_error") from error
+
+
+def _load_mcp_config_file(path: Path) -> MCPConfig:
+    if not path.exists():
+        return MCPConfig()
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise MCPConfigError(f"Invalid MCP config: {type(error).__name__}") from error
+    try:
+        return MCPConfig.model_validate(
+            payload,
+            context={"allow_secret_templates": True},
+        )
+    except ValidationError as error:
+        raise MCPConfigError("Invalid MCP config: validation_error") from error
+
+
+def _resolve_secrets(value: object, environment: Mapping[str, str | None]) -> object:
+    if isinstance(value, dict):
+        return {key: _resolve_secrets(item, environment) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_resolve_secrets(item, environment) for item in value]
+    if not isinstance(value, str):
+        return value
+
+    def replace(match: re.Match[str]) -> str:
+        name = match.group(1)
+        replacement = environment.get(name)
+        if replacement is None or replacement == "":
+            raise MCPConfigError(f"Missing environment variable: {name}")
+        return replacement
+
+    return _ENV_PATTERN.sub(replace, value)

mycode/mcp/errors.py

@@ -0,0 +1,302 @@
+from collections.abc import Iterator
+from dataclasses import dataclass
+import ssl
+from typing import Literal
+
+import httpx2
+from mcp import MCPError
+from mcp_types import CONNECTION_CLOSED, REQUEST_TIMEOUT
+
+
+MCPErrorCategory = Literal[
+    "authentication",
+    "permission_denied",
+    "timeout",
+    "connection_error",
+    "tls_error",
+    "protocol_error",
+    "server_unavailable",
+    "unknown",
+]
+
+
+@dataclass(frozen=True)
+class MCPErrorClassification:
+    category: MCPErrorCategory
+    summary: str
+    retryable: bool | None
+    root_error_type: str
+
+
+def classify_mcp_error(error: BaseException) -> MCPErrorClassification:
+    """Classify an MCP failure without exposing provider-controlled text."""
+    chain = tuple(_exception_chain(error))
+
+    http_status = _first_http_status(chain, {401, 403})
+    if http_status is not None:
+        if http_status == 401:
+            return _classification(
+                chain,
+                category="authentication",
+                summary="Authentication failed (401)",
+                retryable=False,
+                predicate=lambda item: _http_status(item) == 401,
+            )
+        return _classification(
+            chain,
+            category="permission_denied",
+            summary="Access forbidden (403)",
+            retryable=False,
+            predicate=lambda item: _http_status(item) == 403,
+        )
+
+    # Transport causes must be checked before MCPError. An MCP client may wrap
+    # a httpx2.ConnectError in a generic "connection closed" MCPError.
+    if any(isinstance(item, ssl.SSLError) for item in chain):
+        return _classification(
+            chain,
+            category="tls_error",
+            summary="TLS connection failed",
+            retryable=True,
+            predicate=lambda item: isinstance(item, ssl.SSLError),
+        )
+    if any(
+        isinstance(item, (TimeoutError, httpx2.TimeoutException))
+        for item in chain
+    ):
+        return _classification(
+            chain,
+            category="timeout",
+            summary="Connection timed out",
+            retryable=True,
+            predicate=lambda item: isinstance(
+                item, (TimeoutError, httpx2.TimeoutException)
+            ),
+        )
+    if any(
+        isinstance(item, ConnectionRefusedError)
+        for item in chain
+    ):
+        return _classification(
+            chain,
+            category="connection_error",
+            summary="Connection refused",
+            retryable=True,
+            predicate=lambda item: isinstance(item, ConnectionRefusedError),
+        )
+    if any(
+        isinstance(
+            item,
+            (
+                httpx2.ConnectError,
+                ConnectionResetError,
+                BrokenPipeError,
+                ConnectionError,
+                EOFError,
+            ),
+        )
+        for item in chain
+    ):
+        return _classification(
+            chain,
+            category="connection_error",
+            summary="Connection failed",
+            retryable=True,
+            predicate=lambda item: isinstance(
+                item,
+                (
+                    httpx2.ConnectError,
+                    ConnectionResetError,
+                    BrokenPipeError,
+                    ConnectionError,
+                    EOFError,
+                ),
+            ),
+        )
+
+    if any(_mcp_error_code(item) == CONNECTION_CLOSED for item in chain):
+        return _classification(
+            chain,
+            category="connection_error",
+            summary="Connection closed",
+            retryable=True,
+            predicate=lambda item: (
+                _mcp_error_code(item) == CONNECTION_CLOSED
+            ),
+        )
+    if any(_mcp_error_code(item) == REQUEST_TIMEOUT for item in chain):
+        return _classification(
+            chain,
+            category="timeout",
+            summary="Request timed out",
+            retryable=True,
+            predicate=lambda item: _mcp_error_code(item) == REQUEST_TIMEOUT,
+        )
+    if any(_is_server_unavailable(item) for item in chain):
+        return _classification(
+            chain,
+            category="server_unavailable",
+            summary="MCP server unavailable",
+            retryable=False,
+            predicate=_is_server_unavailable,
+        )
+    if any(isinstance(item, PermissionError) for item in chain):
+        return _classification(
+            chain,
+            category="permission_denied",
+            summary="Permission denied",
+            retryable=False,
+            predicate=lambda item: isinstance(item, PermissionError),
+        )
+    if any(isinstance(item, FileNotFoundError) for item in chain):
+        return _classification(
+            chain,
+            category="unknown",
+            summary="Server command not found",
+            retryable=False,
+            predicate=lambda item: isinstance(item, FileNotFoundError),
+        )
+    if any(isinstance(item, httpx2.HTTPStatusError) for item in chain):
+        status_code = next(
+            item.response.status_code
+            for item in chain
+            if isinstance(item, httpx2.HTTPStatusError)
+        )
+        if status_code >= 500:
+            return _classification(
+                chain,
+                category="server_unavailable",
+                summary=f"HTTP request failed ({status_code})",
+                retryable=True,
+                predicate=lambda item: (
+                    isinstance(item, httpx2.HTTPStatusError)
+                    and item.response.status_code == status_code
+                ),
+            )
+        return _classification(
+            chain,
+            category="unknown",
+            summary=f"HTTP request failed ({status_code})",
+            retryable=False,
+            predicate=lambda item: isinstance(item, httpx2.HTTPStatusError),
+        )
+    if any(isinstance(item, MCPError) for item in chain):
+        return _classification(
+            chain,
+            category="protocol_error",
+            summary="MCP protocol error",
+            retryable=False,
+            predicate=lambda item: isinstance(item, MCPError),
+        )
+    if any(isinstance(item, OSError) for item in chain):
+        return _classification(
+            chain,
+            category="connection_error",
+            summary="Server process or transport failed",
+            retryable=False,
+            predicate=lambda item: isinstance(item, OSError),
+        )
+
+    return MCPErrorClassification(
+        category="unknown",
+        summary=type(error).__name__,
+        retryable=None,
+        root_error_type=_root_error_type(chain, fallback=error),
+    )
+
+
+def safe_error_summary(error: BaseException) -> str:
+    """Return a short safe summary for CLI and startup status output."""
+    return classify_mcp_error(error).summary
+
+
+def is_transient_mcp_error(classified: MCPErrorClassification) -> bool:
+    """Return whether startup may retry this transport-level failure."""
+    return classified.retryable is True and classified.category in {
+        "timeout",
+        "connection_error",
+        "tls_error",
+    }
+
+
+def _classification(
+    chain: tuple[BaseException, ...],
+    *,
+    category: MCPErrorCategory,
+    summary: str,
+    retryable: bool | None,
+    predicate,
+) -> MCPErrorClassification:
+    matched = next((item for item in chain if predicate(item)), None)
+    return MCPErrorClassification(
+        category=category,
+        summary=summary,
+        retryable=retryable,
+        root_error_type=(
+            type(matched).__name__
+            if matched is not None
+            else type(chain[0]).__name__
+        ),
+    )
+
+
+def _first_http_status(
+    chain: tuple[BaseException, ...], status_codes: set[int]
+) -> int | None:
+    for item in chain:
+        status_code = _http_status(item)
+        if status_code in status_codes:
+            return status_code
+    return None
+
+
+def _http_status(error: BaseException) -> int | None:
+    if not isinstance(error, httpx2.HTTPStatusError):
+        return None
+    return error.response.status_code
+
+
+def _mcp_error_code(error: BaseException) -> int | None:
+    if not isinstance(error, MCPError):
+        return None
+    code = getattr(error, "code", None)
+    if isinstance(code, int) and not isinstance(code, bool):
+        return code
+    return None
+
+
+def _is_server_unavailable(error: BaseException) -> bool:
+    if not isinstance(error, RuntimeError):
+        return False
+    return str(error).strip().casefold() in {
+        "mcp server is unavailable",
+        "mcp server unavailable",
+        "server unavailable",
+    }
+
+
+def _root_error_type(
+    chain: tuple[BaseException, ...], *, fallback: BaseException
+) -> str:
+    for item in reversed(chain):
+        if not isinstance(item, BaseExceptionGroup):
+            return type(item).__name__
+    return type(fallback).__name__
+
+
+def _exception_chain(error: BaseException) -> Iterator[BaseException]:
+    """Walk effective causes and ExceptionGroup members without looping."""
+    seen: set[int] = set()
+    pending: list[BaseException] = [error]
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        yield current
+        if isinstance(current, BaseExceptionGroup):
+            pending.extend(reversed(current.exceptions))
+        if current.__cause__ is not None:
+            pending.append(current.__cause__)
+        elif not current.__suppress_context__ and current.__context__ is not None:
+            pending.append(current.__context__)