gobby 0.2.8__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/servers/routes/mcp/endpoints/execution.py

@@ -7,7 +7,6 @@ These endpoints handle tool listing, schema retrieval, and tool execution.
 
 import json
 import logging
-import re
 import time
 from typing import TYPE_CHECKING, Any
 
@@ -36,6 +35,10 @@ def _process_tool_proxy_result(
     """
     Process tool proxy result with consistent metrics, logging, and error handling.
 
+    All errors (including server-not-found) are returned as {success: False, result: {...}}
+    rather than raising HTTPException. This ensures consistent error formatting for
+    MCP clients, which otherwise show errors as "HTTP 404: {body}" instead of clean messages.
+
     Args:
         result: The result from tool_proxy.call_tool()
         server_name: Name of the MCP server
@@ -44,38 +47,28 @@ def _process_tool_proxy_result(
 
     Returns:
         Wrapped result dict with success status and response time
-
-    Raises:
-        HTTPException: 404 if server not found/not configured
     """
     # Track metrics for tool-level failures vs successes
     if isinstance(result, dict) and result.get("success") is False:
         _metrics.inc_counter("mcp_tool_calls_failed_total")
 
-        # Check structured error code first (preferred)
+        # Return all errors consistently as {success: False, result: {...}}
+        # Previously, server-not-found errors raised HTTPException(404), but this
+        # caused MCP clients to format errors as "HTTP 404: {body}" instead of
+        # showing clean error messages. Consistent error envelopes work better
+        # for both MCP clients (via call_tool) and HTTP clients.
         error_code = result.get("error_code")
-        if error_code in ("SERVER_NOT_FOUND", "SERVER_NOT_CONFIGURED"):
-            # Normalize result to standard error shape while preserving existing fields
-            normalized = {"success": False, "error": result.get("error", "Unknown error")}
-            for key, value in result.items():
-                if key not in normalized:
-                    normalized[key] = value
-            raise HTTPException(status_code=404, detail=normalized)
-
-        # Backward compatibility: fall back to regex matching if no error_code
-        if not error_code:
+        if error_code:
             logger.debug(
-                "ToolProxyService returned error without error_code - using regex fallback"
+                f"MCP tool call failed: {server_name}.{tool_name} (error_code={error_code})",
+                extra={
+                    "server": server_name,
+                    "tool": tool_name,
+                    "error_code": error_code,
+                },
             )
-            error_msg = str(result.get("error", ""))
-            if re.search(r"server\s+(not\s+found|not\s+configured)", error_msg, re.IGNORECASE):
-                normalized = {"success": False, "error": result.get("error", "Unknown error")}
-                for key, value in result.items():
-                    if key not in normalized:
-                        normalized[key] = value
-                raise HTTPException(status_code=404, detail=normalized)
-
-        # Tool-level failure (not a transport error) - return failure envelope
+
+        # Tool-level failure - return failure envelope (not HTTP exception)
         return {
             "success": False,
             "result": result,
@@ -318,12 +311,16 @@ async def get_tool_schema(
                 schema = registry.get_schema(tool_name)
                 if schema:
                     response_time_ms = (time.perf_counter() - start_time) * 1000
-                    return {
-                        "name": tool_name,
+                    # Build response with description only if present
+                    result: dict[str, Any] = {
+                        "name": schema.get("name", tool_name),
+                        "inputSchema": schema.get("inputSchema"),
                         "server": server_name,
-                        "inputSchema": schema,
                         "response_time_ms": response_time_ms,
                     }
+                    if schema.get("description"):
+                        result["description"] = schema["description"]
+                    return result
                 raise HTTPException(
                     status_code=404,
                     detail={
@@ -340,15 +337,19 @@ async def get_tool_schema(
 
         # Get from external MCP server
         try:
-            schema = await server.mcp_manager.get_tool_input_schema(server_name, tool_name)
+            tool_info = await server.mcp_manager.get_tool_info(server_name, tool_name)
             response_time_ms = (time.perf_counter() - start_time) * 1000
 
-            return {
-                "name": tool_name,
+            # Build response with description only if present
+            response: dict[str, Any] = {
+                "name": tool_info.get("name", tool_name),
+                "inputSchema": tool_info.get("inputSchema"),
                 "server": server_name,
-                "inputSchema": schema,
                 "response_time_ms": response_time_ms,
             }
+            if tool_info.get("description"):
+                response["description"] = tool_info["description"]
+            return response
 
         except (KeyError, ValueError) as e:
             # Tool or server not found - 404

gobby/servers/routes/mcp/endpoints/registry.py

@@ -255,17 +255,17 @@ async def refresh_mcp_tools(
                     try:
                         session = await server.mcp_manager.ensure_connected(server_name)
                         tools_result = await session.list_tools()
-                        for t in tools_result.tools:
+                        for mcp_tool in tools_result.tools:
                             schema = None
-                            if hasattr(t, "inputSchema"):
-                                if hasattr(t.inputSchema, "model_dump"):
-                                    schema = t.inputSchema.model_dump()
-                                elif isinstance(t.inputSchema, dict):
-                                    schema = t.inputSchema
+                            if hasattr(mcp_tool, "inputSchema"):
+                                if hasattr(mcp_tool.inputSchema, "model_dump"):
+                                    schema = mcp_tool.inputSchema.model_dump()
+                                elif isinstance(mcp_tool.inputSchema, dict):
+                                    schema = mcp_tool.inputSchema
                             tools.append(
                                 {
-                                    "name": getattr(t, "name", ""),
-                                    "description": getattr(t, "description", ""),
+                                    "name": getattr(mcp_tool, "name", ""),
+                                    "description": getattr(mcp_tool, "description", ""),
                                     "inputSchema": schema,
                                 }
                             )

gobby/servers/routes/mcp/hooks.py

@@ -113,12 +113,21 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
             from gobby.adapters.base import BaseAdapter
             from gobby.adapters.claude_code import ClaudeCodeAdapter
             from gobby.adapters.codex_impl.adapter import CodexNotifyAdapter
+            from gobby.adapters.copilot import CopilotAdapter
+            from gobby.adapters.cursor import CursorAdapter
             from gobby.adapters.gemini import GeminiAdapter
+            from gobby.adapters.windsurf import WindsurfAdapter
 
             if source == "claude":
                 adapter: BaseAdapter = ClaudeCodeAdapter(hook_manager=hook_manager)
             elif source == "antigravity":
                 adapter = ClaudeCodeAdapter(hook_manager=hook_manager)  # Same format as Claude
+            elif source == "cursor":
+                adapter = CursorAdapter(hook_manager=hook_manager)
+            elif source == "windsurf":
+                adapter = WindsurfAdapter(hook_manager=hook_manager)
+            elif source == "copilot":
+                adapter = CopilotAdapter(hook_manager=hook_manager)
             elif source == "gemini":
                 adapter = GeminiAdapter(hook_manager=hook_manager)
             elif source == "codex":
@@ -126,7 +135,7 @@ def create_hooks_router(server: "HTTPServer") -> APIRouter:
             else:
                 raise HTTPException(
                     status_code=400,
-                    detail=f"Unsupported source: {source}. Supported: claude, antigravity, gemini, codex",
+                    detail=f"Unsupported source: {source}. Supported: claude, antigravity, gemini, codex, cursor, windsurf, copilot",
                 )
 
             # Execute hook via adapter

gobby/servers/routes/pipelines.py

@@ -0,0 +1,227 @@
+"""
+Pipeline routes for Gobby HTTP server.
+
+Provides endpoints for running, approving, and monitoring pipelines.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from gobby.servers.http import HTTPServer
+
+logger = logging.getLogger(__name__)
+
+
+class PipelineRunRequest(BaseModel):
+    """Request body for POST /api/pipelines/run."""
+
+    name: str
+    inputs: dict[str, Any] = {}
+    project_id: str | None = None
+
+
+class PipelineRunResponse(BaseModel):
+    """Response body for successful pipeline execution."""
+
+    status: str
+    execution_id: str
+    pipeline_name: str
+    outputs: dict[str, Any] | None = None
+
+
+class PipelineApprovalResponse(BaseModel):
+    """Response body when pipeline requires approval."""
+
+    status: str
+    execution_id: str
+    step_id: str
+    token: str
+    message: str
+
+
+def create_pipelines_router(server: "HTTPServer") -> APIRouter:
+    """
+    Create pipelines router with endpoints bound to server instance.
+
+    Args:
+        server: HTTPServer instance for accessing state and dependencies
+
+    Returns:
+        Configured APIRouter with pipeline endpoints
+    """
+    router = APIRouter(prefix="/api/pipelines", tags=["pipelines"])
+
+    @router.post("/run", response_model=None)
+    async def run_pipeline(request: PipelineRunRequest) -> dict[str, Any] | JSONResponse:
+        """
+        Run a pipeline by name.
+
+        Returns:
+            200: Pipeline completed successfully
+            202: Pipeline waiting for approval
+            404: Pipeline not found
+            500: Execution error
+        """
+        from gobby.workflows.pipeline_state import ApprovalRequired
+
+        # Get loader and executor from services
+        loader = server.services.workflow_loader
+        executor = server.services.pipeline_executor
+
+        if loader is None:
+            raise HTTPException(status_code=500, detail="Workflow loader not configured")
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        # Load the pipeline
+        pipeline = loader.load_pipeline(request.name)
+        if pipeline is None:
+            raise HTTPException(status_code=404, detail=f"Pipeline '{request.name}' not found")
+
+        try:
+            # Execute the pipeline
+            execution = await executor.execute(
+                pipeline=pipeline,
+                inputs=request.inputs,
+                project_id=request.project_id or "",
+            )
+
+            # Return success response
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ApprovalRequired as e:
+            # Return 202 Accepted for approval required
+            return JSONResponse(
+                status_code=202,
+                content={
+                    "status": "waiting_approval",
+                    "execution_id": e.execution_id,
+                    "step_id": e.step_id,
+                    "token": e.token,
+                    "message": e.message,
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"Pipeline execution failed: {e}", exc_info=True)
+            raise HTTPException(status_code=500, detail=f"Execution error: {e}") from None
+
+    @router.get("/{execution_id}")
+    async def get_execution(execution_id: str) -> dict[str, Any]:
+        """
+        Get execution details by ID.
+
+        Returns:
+            200: Execution details with steps
+            404: Execution not found
+        """
+        # Get execution manager from services
+        execution_manager = server.services.pipeline_execution_manager
+
+        if execution_manager is None:
+            raise HTTPException(status_code=500, detail="Pipeline execution manager not configured")
+
+        # Fetch execution
+        execution = execution_manager.get_execution(execution_id)
+        if execution is None:
+            raise HTTPException(status_code=404, detail=f"Execution '{execution_id}' not found")
+
+        # Fetch steps
+        steps = execution_manager.get_steps_for_execution(execution_id)
+
+        return {
+            "id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "project_id": execution.project_id,
+            "status": execution.status.value,
+            "created_at": execution.created_at,
+            "updated_at": execution.updated_at,
+            "steps": [
+                {
+                    "id": step.id,
+                    "step_id": step.step_id,
+                    "status": step.status.value,
+                }
+                for step in steps
+            ],
+        }
+
+    @router.post("/approve/{token}", response_model=None)
+    async def approve_execution(token: str) -> dict[str, Any] | JSONResponse:
+        """
+        Approve a pipeline execution waiting for approval.
+
+        Returns:
+            200: Execution resumed and completed (or continued)
+            202: Execution resumed but needs another approval
+            404: Invalid token
+        """
+        from gobby.workflows.pipeline_state import ApprovalRequired
+
+        executor = server.services.pipeline_executor
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        try:
+            execution = await executor.approve(token, approved_by=None)
+
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ApprovalRequired as e:
+            # Pipeline needs another approval
+            return JSONResponse(
+                status_code=202,
+                content={
+                    "status": "waiting_approval",
+                    "execution_id": e.execution_id,
+                    "step_id": e.step_id,
+                    "token": e.token,
+                    "message": e.message,
+                },
+            )
+
+        except ValueError as e:
+            raise HTTPException(status_code=404, detail=f"Invalid token: {e}") from None
+
+    @router.post("/reject/{token}")
+    async def reject_execution(token: str) -> dict[str, Any]:
+        """
+        Reject a pipeline execution waiting for approval.
+
+        Returns:
+            200: Execution rejected/cancelled
+            404: Invalid token
+        """
+        executor = server.services.pipeline_executor
+
+        if executor is None:
+            raise HTTPException(status_code=500, detail="Pipeline executor not configured")
+
+        try:
+            execution = await executor.reject(token, rejected_by=None)
+
+            return {
+                "status": execution.status.value,
+                "execution_id": execution.id,
+                "pipeline_name": execution.pipeline_name,
+            }
+
+        except ValueError as e:
+            raise HTTPException(status_code=404, detail=f"Invalid token: {e}") from None
+
+    return router