crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/mcp/client.py

@@ -0,0 +1,169 @@
+"""MCP client — connects to MCP servers and loads tools."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.types.config import McpServerConfig
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+logger = get_logger(__name__)
+
+
+def _normalize_name(name: str) -> str:
+    """Normalize a server/tool name to a valid identifier."""
+    return re.sub(r'[^a-zA-Z0-9_]', '_', name)
+
+
+def build_mcp_tool_name(server_name: str, tool_name: str) -> str:
+    """Build the prefixed MCP tool name."""
+    return f"mcp__{_normalize_name(server_name)}__{_normalize_name(tool_name)}"
+
+
+class McpToolWrapper(Tool):
+    """Wraps an MCP tool as a CrabCode Tool."""
+
+    def __init__(
+        self,
+        server_name: str,
+        tool_name: str,
+        description: str,
+        schema: dict[str, Any],
+        client: Any,
+    ):
+        self.name = build_mcp_tool_name(server_name, tool_name)
+        self.description = description
+        self.input_schema = schema
+        self.is_read_only = False
+        self.is_concurrency_safe = True
+        self.is_enabled = True
+
+        self._server_name = server_name
+        self._original_name = tool_name
+        self._client = client
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        try:
+            result = await self._client.call_tool(self._original_name, tool_input)
+
+            text_parts: list[str] = []
+            if hasattr(result, "content"):
+                for block in result.content:
+                    if hasattr(block, "text"):
+                        text_parts.append(block.text)
+
+            output = "\n".join(text_parts) if text_parts else str(result)
+            is_error = getattr(result, "isError", False)
+
+            return ToolResult(
+                data=result,
+                result_for_model=output,
+                is_error=is_error,
+            )
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"MCP tool error: {e}",
+                is_error=True,
+            )
+
+
+class McpManager:
+    """Manages MCP server connections and tool discovery."""
+
+    def __init__(self) -> None:
+        self._connections: dict[str, Any] = {}
+        self._tools: list[McpToolWrapper] = []
+
+    async def connect(
+        self,
+        servers: dict[str, McpServerConfig],
+    ) -> list[McpToolWrapper]:
+        """Connect to all configured MCP servers and fetch tools."""
+        all_tools: list[McpToolWrapper] = []
+
+        for name, config in servers.items():
+            if config.disabled:
+                continue
+
+            try:
+                tools = await self._connect_server(name, config)
+                all_tools.extend(tools)
+            except Exception:
+                logger.exception("Failed to connect MCP server: %s", name)
+
+        self._tools = all_tools
+        return all_tools
+
+    async def _connect_server(
+        self,
+        name: str,
+        config: McpServerConfig,
+    ) -> list[McpToolWrapper]:
+        """Connect to a single MCP server."""
+        try:
+            from mcp import ClientSession, StdioServerParameters
+            from mcp.client.stdio import stdio_client
+        except ImportError:
+            logger.warning("MCP package not installed; skipping server %s", name)
+            return []
+
+        if not config.command:
+            return []
+
+        env = {**os.environ, **config.env}
+        server_params = StdioServerParameters(
+            command=config.command[0],
+            args=config.command[1:] if len(config.command) > 1 else [],
+            env=env,
+        )
+
+        try:
+            read_stream, write_stream = await asyncio.wait_for(
+                stdio_client(server_params).__aenter__(),
+                timeout=30,
+            )
+            session = ClientSession(read_stream, write_stream)
+            initialization = await session.initialize()
+            self._connections[name] = session
+
+            tools_response = await session.list_tools()
+            tools: list[McpToolWrapper] = []
+            for tool_info in tools_response.tools:
+                wrapper = McpToolWrapper(
+                    server_name=name,
+                    tool_name=tool_info.name,
+                    description=tool_info.description or "",
+                    schema=tool_info.inputSchema or {"type": "object", "properties": {}},
+                    client=session,
+                )
+                tools.append(wrapper)
+                wrapper.server_instructions = getattr(initialization, "instructions", None) or ""
+
+            return tools
+
+        except Exception:
+            logger.exception("MCP connection failed for server %s", name)
+            return []
+
+    @property
+    def tools(self) -> list[McpToolWrapper]:
+        return self._tools
+
+    async def disconnect_all(self) -> None:
+        """Disconnect from all MCP servers."""
+        for session in self._connections.values():
+            try:
+                await session.__aexit__(None, None, None)
+            except Exception:
+                logger.exception("Failed to disconnect MCP session cleanly")
+        self._connections.clear()
+        self._tools.clear()

crabcode_core/mcp/config.py

@@ -0,0 +1,57 @@
+"""MCP configuration — multi-scope server config loading and merging."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.paths import get_config_home
+from crabcode_core.types.config import McpServerConfig
+
+logger = get_logger(__name__)
+
+
+def load_mcp_configs(cwd: str) -> dict[str, McpServerConfig]:
+    """Load and merge MCP server configurations from multiple scopes.
+
+    Scopes (later overrides earlier):
+      1. User ($CRABCODE_HOME/mcp_servers.json; default ~/.crabcode)
+      2. Project (<project>/.crabcode/mcp_servers.json)
+      3. Local (<project>/.crabcode/mcp_servers.local.json)
+    """
+    merged: dict[str, dict[str, Any]] = {}
+    home = Path.home()
+
+    paths = [
+        get_config_home() / "mcp_servers.json",
+        home / ".claude" / "mcp_servers.json",
+        Path(cwd).resolve() / ".crabcode" / "mcp_servers.json",
+        Path(cwd).resolve() / ".claude" / "mcp_servers.json",
+        Path(cwd).resolve() / ".crabcode" / "mcp_servers.local.json",
+    ]
+
+    for path in paths:
+        if not path.exists():
+            continue
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+            if isinstance(raw, dict):
+                servers = raw.get("mcpServers", raw)
+                if isinstance(servers, dict):
+                    for name, config in servers.items():
+                        if isinstance(config, dict):
+                            merged[name] = {**merged.get(name, {}), **config}
+        except (json.JSONDecodeError, OSError):
+            logger.warning("Failed to load MCP config file: %s", path, exc_info=True)
+            continue
+
+    result: dict[str, McpServerConfig] = {}
+    for name, raw in merged.items():
+        try:
+            result[name] = McpServerConfig.model_validate(raw)
+        except Exception:
+            logger.warning("Skipping invalid MCP server config: %s", name, exc_info=True)
+
+    return result

crabcode_core/path_validation.py

@@ -0,0 +1,34 @@
+"""Validation helpers for portable filesystem path components."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+_WINDOWS_INVALID_CHARS = frozenset('<>:"|?*')
+_WINDOWS_RESERVED_NAMES = frozenset(
+    {"CON", "PRN", "AUX", "NUL"}
+    | {f"COM{number}" for number in range(1, 10)}
+    | {f"LPT{number}" for number in range(1, 10)}
+)
+
+
+def validate_path_component(value: str, label: str) -> str:
+    """Return a safe, cross-platform filename component or raise ValueError."""
+    if not isinstance(value, str) or not value or value in {".", ".."}:
+        raise ValueError(f"Invalid {label}")
+    if Path(value).is_absolute() or "/" in value or "\\" in value:
+        raise ValueError(f"Invalid {label}: path separators are not allowed")
+    if any(ord(character) < 32 or ord(character) == 127 for character in value):
+        raise ValueError(f"Invalid {label}: control characters are not allowed")
+    invalid = sorted(set(value) & _WINDOWS_INVALID_CHARS)
+    if invalid:
+        raise ValueError(
+            f"Invalid {label}: unsupported filename character(s): {''.join(invalid)}"
+        )
+    if value.endswith((" ", ".")):
+        raise ValueError(f"Invalid {label}: trailing spaces and dots are not allowed")
+    stem = value.split(".", 1)[0].rstrip(" .").upper()
+    if stem in _WINDOWS_RESERVED_NAMES:
+        raise ValueError(f"Invalid {label}: reserved Windows device name")
+    return value

crabcode_core/paths.py

@@ -0,0 +1,24 @@
+"""Shared locations for CrabCode's user-level configuration and state."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def get_config_home() -> Path:
+    """Return CRABCODE_HOME, or ~/.crabcode when unset or blank.
+
+    Require an absolute directory so processes launched in different projects
+    share the same home. A leading ``~`` for the current user is supported.
+    This function does not create the directory or migrate existing data.
+    """
+    override = os.environ.get("CRABCODE_HOME", "").strip()
+    if not override:
+        return Path.home() / ".crabcode"
+    path = Path(override)
+    if path.parts and path.parts[0] == "~":
+        path = Path.home().joinpath(*path.parts[1:])
+    if not path.is_absolute():
+        raise ValueError("CRABCODE_HOME must be an absolute directory path (or start with ~/)")
+    return path

crabcode_core/peer/__init__.py

@@ -0,0 +1,10 @@
+"""Cross-session peer discovery and messaging."""
+
+from crabcode_core.peer.runtime import (
+    PeerDelivery,
+    PeerMessage,
+    PeerRecord,
+    PeerRuntime,
+)
+
+__all__ = ["PeerDelivery", "PeerMessage", "PeerRecord", "PeerRuntime"]