gobby 0.2.5__py3-none-any.whl

gobby/mcp_proxy/services/server_mgmt.py

@@ -0,0 +1,214 @@
+"""Server management service."""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from gobby.mcp_proxy.manager import MCPClientManager
+from gobby.mcp_proxy.models import MCPServerConfig
+
+if TYPE_CHECKING:
+    from gobby.config.app import DaemonConfig
+
+logger = logging.getLogger("gobby.mcp.server")
+
+
+class ServerManagementService:
+    """Service for managing MCP server configurations."""
+
+    def __init__(
+        self,
+        mcp_manager: MCPClientManager,
+        config_manager: Any,
+        config: "DaemonConfig | None" = None,
+    ):
+        """
+        Args:
+            mcp_manager: MCP client manager
+            config_manager: Config manager (for saving changes)
+            config: Daemon configuration (for import operations)
+        """
+        self._mcp_manager = mcp_manager
+        self._config_manager = config_manager
+        self._config = config
+
+    async def add_server(
+        self,
+        name: str,
+        transport: str,
+        url: str | None = None,
+        command: str | None = None,
+        args: list[str] | None = None,
+        env: dict[str, str] | None = None,
+        headers: dict[str, str] | None = None,
+        enabled: bool = True,
+        project_id: str | None = None,
+    ) -> dict[str, Any]:
+        """Add a new MCP server."""
+        try:
+            # Resolve project ID
+            if not project_id:
+                from gobby.utils.project_context import get_project_context
+
+                ctx = get_project_context()
+                if ctx and ctx.get("id"):
+                    project_id = ctx["id"]
+
+            if not project_id:
+                return {
+                    "success": False,
+                    "error": "project_id is required. Run 'gobby init' or provide project_id.",
+                }
+
+            # Create config object
+            server_config = MCPServerConfig(
+                name=name,
+                project_id=project_id,
+                transport=transport,
+                url=url,
+                command=command,
+                args=args,
+                env=env,
+                headers=headers,
+                enabled=enabled,
+            )
+            # Validate - catch validation errors separately for clear error messages
+            try:
+                server_config.validate()
+            except ValueError as e:
+                return {"success": False, "error": f"Validation error: {e}"}
+
+            # Add to manager (runtime)
+            self._mcp_manager.add_server_config(server_config)
+
+            # Persist to config
+            # self._config_manager.add_mcp_server(...) # Mocking this interaction
+
+            # Attempt connection
+            if enabled:
+                try:
+                    await self._mcp_manager.connect_all([server_config])
+                except Exception as e:
+                    logger.warning(f"Added server {name} but connection failed: {e}")
+                    return {
+                        "success": True,
+                        "message": f"Server added but connection failed: {str(e)}",
+                        "connected": False,
+                    }
+
+            return {
+                "success": True,
+                "message": f"Server {name} added successfully",
+                "connected": enabled,
+            }
+
+        except Exception as e:
+            logger.exception(f"Unexpected error adding server {name}")
+            return {"success": False, "error": str(e)}
+
+    async def remove_server(self, name: str) -> dict[str, Any]:
+        """Remove an MCP server.
+
+        Disconnects the server first if connected, then removes the configuration.
+        """
+        try:
+            # First disconnect if connected
+            if name in self._mcp_manager._connections:
+                try:
+                    connection = self._mcp_manager._connections[name]
+                    if connection.is_connected:
+                        await connection.disconnect()
+                    # Update health state
+                    if name in self._mcp_manager.health:
+                        from gobby.mcp_proxy.models import ConnectionState
+
+                        self._mcp_manager.health[name].state = ConnectionState.DISCONNECTED
+                    # Remove from connections
+                    del self._mcp_manager._connections[name]
+                    logger.info(f"Disconnected server {name} before removal")
+                except Exception as e:
+                    logger.warning(f"Error disconnecting server {name}: {e}")
+                    # Continue with removal even if disconnect fails
+
+            # Remove from runtime config
+            self._mcp_manager.remove_server_config(name)
+
+            # Persist
+            # self._config_manager.remove_mcp_server(name)
+
+            return {"success": True, "message": f"Server {name} removed"}
+        except Exception as e:
+            logger.error(f"Failed to remove server {name}: {e}")
+            return {"success": False, "error": str(e)}
+
+    async def import_server(
+        self,
+        from_project: str | None = None,
+        github_url: str | None = None,
+        query: str | None = None,
+        servers: list[str] | None = None,
+    ) -> dict[str, Any]:
+        """Import MCP server(s) from various sources.
+
+        Args:
+            from_project: Import from another Gobby project by name or ID
+            github_url: Import from a GitHub repository URL
+            query: Import by natural language search query
+            servers: Optional list of specific server names to import
+
+        Returns:
+            Result dict with imported servers or error
+        """
+        # Validate at least one source is provided
+        if not from_project and not github_url and not query:
+            return {
+                "success": False,
+                "error": "Specify at least one: from_project, github_url, or query",
+            }
+
+        # Get current project context
+        from gobby.utils.project_context import get_project_context
+
+        project_ctx = get_project_context()
+        if not project_ctx or not project_ctx.get("id"):
+            return {
+                "success": False,
+                "error": "No current project. Run 'gobby init' first.",
+            }
+        current_project_id = project_ctx["id"]
+
+        # Validate config is available
+        if not self._config:
+            return {
+                "success": False,
+                "error": "Daemon configuration not available for import operations",
+            }
+
+        try:
+            # Create importer lazily with required dependencies
+            from gobby.mcp_proxy.importer import MCPServerImporter
+            from gobby.storage.database import LocalDatabase
+
+            db = LocalDatabase()
+            importer = MCPServerImporter(
+                config=self._config,
+                db=db,
+                current_project_id=current_project_id,
+                mcp_client_manager=self._mcp_manager,
+            )
+
+            # Execute import based on source
+            if from_project:
+                return await importer.import_from_project(
+                    source_project=from_project,
+                    servers=servers,
+                )
+            elif github_url:
+                return await importer.import_from_github(github_url)
+            elif query:
+                return await importer.import_from_query(query)
+            else:
+                return {"success": False, "error": "No import source specified"}
+
+        except Exception as e:
+            logger.exception("Failed to import MCP server")
+            return {"success": False, "error": str(e)}

gobby/mcp_proxy/services/system.py

@@ -0,0 +1,72 @@
+"""System status service."""
+
+import logging
+import os
+from typing import Any
+
+from gobby.mcp_proxy.manager import MCPClientManager
+
+logger = logging.getLogger("gobby.mcp.server")
+
+
+class SystemService:
+    """Service for system status and information."""
+
+    def __init__(
+        self, mcp_manager: MCPClientManager, port: int, websocket_port: int, start_time: float
+    ):
+        self._mcp_manager = mcp_manager
+        self._port = port
+        self._websocket_port = websocket_port
+        self._start_time = start_time
+
+    def get_status(self) -> dict[str, Any]:
+        """Get system status."""
+        health = self._mcp_manager.get_server_health()
+        lazy_states = self._mcp_manager.get_lazy_connection_states()
+
+        # Merge lazy connection info into health
+        for name, lazy_info in lazy_states.items():
+            if name in health:
+                health[name]["lazy_connection"] = lazy_info
+            else:
+                # Server registered but never connected (lazy mode)
+                health[name] = {
+                    "state": "configured",  # Not connected yet
+                    "health": "unknown",
+                    "last_check": None,
+                    "failures": 0,
+                    "response_time_ms": None,
+                    "lazy_connection": lazy_info,
+                }
+
+        # Aggregate health: system is healthy if connected servers are healthy
+        # In lazy mode, unconfigured servers don't count as unhealthy
+        all_healthy = (
+            all(
+                server_health.get("state") in ["connected", "healthy", "configured"]
+                for server_health in health.values()
+            )
+            if health
+            else True
+        )
+
+        # Count configured vs connected
+        configured_count = len(health)
+        connected_count = sum(
+            1
+            for h in health.values()
+            if h.get("state") == "connected" or h.get("lazy_connection", {}).get("is_connected")
+        )
+
+        return {
+            "running": True,
+            "pid": os.getpid(),
+            "healthy": all_healthy,
+            "http_port": self._port,
+            "websocket_port": self._websocket_port,
+            "mcp_servers": health,
+            "lazy_mode": self._mcp_manager.lazy_connect,
+            "configured_servers": configured_count,
+            "connected_servers": connected_count,
+        }

gobby/mcp_proxy/services/tool_filter.py

@@ -0,0 +1,231 @@
+"""Tool filtering service based on workflow step restrictions."""
+
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.storage.database import LocalDatabase
+    from gobby.workflows.loader import WorkflowLoader
+    from gobby.workflows.state_manager import WorkflowStateManager
+
+logger = logging.getLogger("gobby.mcp.tool_filter")
+
+
+class ToolFilterService:
+    """
+    Service to filter tools based on workflow step restrictions.
+
+    When a session has an active step-based workflow, this service
+    filters the tool list to only include tools allowed in the current step.
+    """
+
+    def __init__(
+        self,
+        db: "LocalDatabase | None" = None,
+        loader: "WorkflowLoader | None" = None,
+        state_manager: "WorkflowStateManager | None" = None,
+    ):
+        self._db = db
+        self._loader = loader
+        self._state_manager = state_manager
+
+    def _get_state_manager(self) -> "WorkflowStateManager | None":
+        """Lazy initialization of state manager."""
+        if self._state_manager:
+            return self._state_manager
+
+        if self._db:
+            from gobby.workflows.state_manager import WorkflowStateManager
+
+            self._state_manager = WorkflowStateManager(self._db)
+            return self._state_manager
+
+        return None
+
+    def _get_loader(self) -> "WorkflowLoader | None":
+        """Lazy initialization of workflow loader."""
+        if self._loader:
+            return self._loader
+
+        from gobby.workflows.loader import WorkflowLoader
+
+        self._loader = WorkflowLoader()
+        return self._loader
+
+    def get_step_restrictions(
+        self,
+        session_id: str,
+        project_path: str | Path | None = None,
+    ) -> dict[str, Any] | None:
+        """
+        Get tool restrictions for the current workflow step.
+
+        Args:
+            session_id: Session ID to check
+            project_path: Optional project path for loading workflow
+
+        Returns:
+            Dict with allowed_tools and blocked_tools, or None if no workflow active
+        """
+        state_manager = self._get_state_manager()
+        if not state_manager:
+            logger.debug("No state manager available for tool filtering")
+            return None
+
+        state = state_manager.get_state(session_id)
+        if not state:
+            logger.debug(f"No workflow state for session {session_id}")
+            return None
+
+        loader = self._get_loader()
+        if not loader:
+            logger.debug("No workflow loader available")
+            return None
+
+        proj = Path(project_path) if project_path else None
+        definition = loader.load_workflow(state.workflow_name, proj)
+        if not definition:
+            logger.warning(f"Workflow '{state.workflow_name}' not found")
+            return None
+
+        step = definition.get_step(state.step)
+        if not step:
+            logger.warning(f"Step '{state.step}' not found in workflow '{state.workflow_name}'")
+            return None
+
+        return {
+            "workflow_name": state.workflow_name,
+            "step": state.step,
+            "allowed_tools": step.allowed_tools,
+            "blocked_tools": step.blocked_tools,
+        }
+
+    def is_tool_allowed(
+        self,
+        tool_name: str,
+        session_id: str,
+        project_path: str | Path | None = None,
+    ) -> tuple[bool, str | None]:
+        """
+        Check if a tool is allowed in the current workflow step.
+
+        Args:
+            tool_name: Name of the tool to check
+            session_id: Session ID
+            project_path: Optional project path
+
+        Returns:
+            Tuple of (is_allowed, reason). If no workflow is active, returns (True, None).
+        """
+        restrictions = self.get_step_restrictions(session_id, project_path)
+        if not restrictions:
+            return True, None
+
+        # Check blocked list first
+        if tool_name in restrictions["blocked_tools"]:
+            return False, f"Tool '{tool_name}' is blocked in step '{restrictions['step']}'"
+
+        # Check allowed list
+        allowed = restrictions["allowed_tools"]
+        if allowed == "all":
+            return True, None
+
+        if tool_name not in allowed:
+            return (
+                False,
+                f"Tool '{tool_name}' is not in allowed list for step '{restrictions['step']}'",
+            )
+
+        return True, None
+
+    def filter_tools(
+        self,
+        tools: list[dict[str, Any]],
+        session_id: str | None = None,
+        project_path: str | Path | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Filter a list of tools based on workflow step restrictions.
+
+        Args:
+            tools: List of tool dicts with at least a 'name' key
+            session_id: Session ID to check for workflow state
+            project_path: Optional project path
+
+        Returns:
+            Filtered list of tools. If no session_id or no active workflow,
+            returns the original list unchanged.
+        """
+        if not session_id:
+            return tools
+
+        restrictions = self.get_step_restrictions(session_id, project_path)
+        if not restrictions:
+            return tools
+
+        allowed = restrictions["allowed_tools"]
+        blocked = restrictions["blocked_tools"]
+
+        filtered = []
+        for tool in tools:
+            name = tool.get("name", "")
+
+            # Skip blocked tools
+            if name in blocked:
+                logger.debug(f"Filtering out blocked tool: {name}")
+                continue
+
+            # Check allowed list
+            if allowed != "all" and name not in allowed:
+                logger.debug(f"Filtering out non-allowed tool: {name}")
+                continue
+
+            filtered.append(tool)
+
+        if len(filtered) < len(tools):
+            logger.info(
+                f"Filtered {len(tools) - len(filtered)} tools based on step '{restrictions['step']}'"
+            )
+
+        return filtered
+
+    def filter_servers_tools(
+        self,
+        servers: list[dict[str, Any]],
+        session_id: str | None = None,
+        project_path: str | Path | None = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Filter tools from multiple servers based on workflow step restrictions.
+
+        Args:
+            servers: List of server dicts with 'name' and 'tools' keys
+            session_id: Session ID to check for workflow state
+            project_path: Optional project path
+
+        Returns:
+            Servers list with filtered tools. Empty servers are kept but with empty tool lists.
+        """
+        if not session_id:
+            return servers
+
+        restrictions = self.get_step_restrictions(session_id, project_path)
+        if not restrictions:
+            return servers
+
+        result = []
+        for server in servers:
+            server_name = server.get("name", "")
+            tools = server.get("tools", [])
+
+            filtered_tools = self.filter_tools(tools, session_id, project_path)
+
+            result.append(
+                {
+                    "name": server_name,
+                    "tools": filtered_tools,
+                }
+            )
+
+        return result