gobby 0.2.5__py3-none-any.whl

gobby/servers/routes/admin.py

@@ -0,0 +1,416 @@
+"""
+Admin routes for Gobby HTTP server.
+
+Provides status, metrics, config, and shutdown endpoints.
+"""
+
+import asyncio
+import logging
+import os
+import time
+from typing import TYPE_CHECKING, Any
+
+import psutil
+from fastapi import APIRouter
+from fastapi.responses import PlainTextResponse
+
+from gobby.utils.metrics import Counter, get_metrics_collector
+from gobby.utils.version import get_version
+
+if TYPE_CHECKING:
+    from gobby.servers.http import HTTPServer
+
+logger = logging.getLogger(__name__)
+
+
+def create_admin_router(server: "HTTPServer") -> APIRouter:
+    """
+    Create admin router with endpoints bound to server instance.
+
+    Args:
+        server: HTTPServer instance for accessing state and dependencies
+
+    Returns:
+        Configured APIRouter with admin endpoints
+    """
+    router = APIRouter(prefix="/admin", tags=["admin"])
+
+    @router.get("/status")
+    async def status_check() -> dict[str, Any]:
+        """
+        Comprehensive status check endpoint.
+
+        Returns detailed health status including daemon state, uptime,
+        memory usage, background tasks, and connection statistics.
+        """
+        start_time = time.perf_counter()
+
+        # Get server uptime
+        uptime_seconds = None
+        if server._start_time is not None:
+            uptime_seconds = time.time() - server._start_time
+
+        # Get daemon status if available
+        daemon_status = None
+        if server._daemon is not None:
+            try:
+                daemon_status = server._daemon.status()
+            except Exception as e:
+                logger.warning(f"Failed to get daemon status: {e}")
+
+        # Get process metrics
+        try:
+            process = psutil.Process(os.getpid())
+            memory_info = process.memory_info()
+            # Run cpu_percent in a thread executor to avoid blocking the event loop
+            # (interval=0.1 would block for 100ms otherwise)
+            cpu_percent = await asyncio.to_thread(process.cpu_percent, 0.1)
+
+            process_metrics = {
+                "memory_rss_mb": round(memory_info.rss / (1024 * 1024), 2),
+                "memory_vms_mb": round(memory_info.vms / (1024 * 1024), 2),
+                "cpu_percent": cpu_percent,
+                "num_threads": process.num_threads(),
+            }
+        except Exception as e:
+            logger.warning(f"Failed to get process metrics: {e}")
+            process_metrics = None
+
+        # Get background task status
+        metrics = get_metrics_collector()
+        background_tasks = {
+            "active": len(server._background_tasks),
+            "total": metrics._counters.get("background_tasks_total", Counter("", "")).value,
+            "completed": metrics._counters.get(
+                "background_tasks_completed_total", Counter("", "")
+            ).value,
+            "failed": metrics._counters.get("background_tasks_failed_total", Counter("", "")).value,
+        }
+
+        # Get MCP server status - include ALL configured servers
+        mcp_health = {}
+        if server.mcp_manager is not None:
+            try:
+                # Iterate over all configured servers, not just connected ones
+                for config in server.mcp_manager.server_configs:
+                    health = server.mcp_manager.health.get(config.name)
+                    is_connected = config.name in server.mcp_manager.connections
+                    mcp_health[config.name] = {
+                        "connected": is_connected,
+                        "status": (
+                            health.state.value
+                            if health
+                            else ("connected" if is_connected else "not_started")
+                        ),
+                        "enabled": config.enabled,
+                        "transport": config.transport,
+                        "health": health.health.value if health else None,
+                        "consecutive_failures": health.consecutive_failures if health else 0,
+                        "last_health_check": (
+                            health.last_health_check.isoformat()
+                            if health and health.last_health_check
+                            else None
+                        ),
+                        "response_time_ms": health.response_time_ms if health else None,
+                    }
+            except Exception as e:
+                logger.warning(f"Failed to get MCP health: {e}")
+
+        # Count internal tools from gobby-* registries and add them to mcp_health
+        internal_tools_count = 0
+        if server._internal_manager:
+            for registry in server._internal_manager.get_all_registries():
+                tools = registry.list_tools()
+                internal_tools_count += len(tools)
+                # Include internal servers in mcp_health for unified server count
+                mcp_health[registry.name] = {
+                    "connected": True,  # Internal servers are always available
+                    "status": "connected",
+                    "enabled": True,
+                    "transport": "internal",
+                    "health": "healthy",
+                    "consecutive_failures": 0,
+                    "last_health_check": None,
+                    "response_time_ms": None,
+                    "internal": True,  # Flag to distinguish from downstream servers
+                    "tool_count": len(tools),
+                }
+
+        # Get session statistics using efficient count queries
+        session_stats = {"active": 0, "paused": 0, "handoff_ready": 0, "total": 0}
+        if server.session_manager is not None:
+            try:
+                # Use count_by_status for efficient grouped counts
+                status_counts = server.session_manager.count_by_status()
+                session_stats["total"] = sum(status_counts.values())
+                session_stats["active"] = status_counts.get("active", 0)
+                session_stats["paused"] = status_counts.get("paused", 0)
+                session_stats["handoff_ready"] = status_counts.get("handoff_ready", 0)
+            except Exception as e:
+                logger.warning(f"Failed to get session stats: {e}")
+
+        # Get task statistics using efficient count queries
+        task_stats = {"open": 0, "in_progress": 0, "closed": 0, "ready": 0, "blocked": 0}
+        if server.task_manager is not None:
+            try:
+                # Use count_by_status for efficient grouped counts
+                status_counts = server.task_manager.count_by_status()
+                task_stats["open"] = status_counts.get("open", 0)
+                task_stats["in_progress"] = status_counts.get("in_progress", 0)
+                task_stats["closed"] = status_counts.get("closed", 0)
+                # Get ready and blocked counts using dedicated count methods
+                task_stats["ready"] = server.task_manager.count_ready_tasks()
+                task_stats["blocked"] = server.task_manager.count_blocked_tasks()
+            except Exception as e:
+                logger.warning(f"Failed to get task stats: {e}")
+
+        # Get memory statistics
+        memory_stats = {"count": 0, "avg_importance": 0.0}
+        if server.memory_manager is not None:
+            try:
+                stats = server.memory_manager.get_stats()
+                memory_stats["count"] = stats.get("total_count", 0)
+                memory_stats["avg_importance"] = stats.get("avg_importance", 0.0)
+            except Exception as e:
+                logger.warning(f"Failed to get memory stats: {e}")
+
+        # Get plugin status
+        plugin_stats: dict[str, Any] = {"enabled": False, "loaded": 0, "handlers": 0}
+        if hasattr(server, "_hook_manager") and server._hook_manager is not None:
+            try:
+                hook_manager = server._hook_manager
+                if hasattr(hook_manager, "plugin_loader") and hook_manager.plugin_loader:
+                    plugin_loader = hook_manager.plugin_loader
+                    plugin_stats["enabled"] = plugin_loader.config.enabled
+                    plugins = plugin_loader.registry.list_plugins()
+                    plugin_stats["loaded"] = len(plugins)
+                    plugin_stats["handlers"] = sum(len(p.get("handlers", [])) for p in plugins)
+                    plugin_stats["plugins"] = [
+                        {
+                            "name": p["name"],
+                            "version": p["version"],
+                            "handlers": len(p.get("handlers", [])),
+                            "actions": len(p.get("actions", [])),
+                        }
+                        for p in plugins
+                    ]
+            except Exception as e:
+                logger.warning(f"Failed to get plugin stats: {e}")
+
+        # Calculate response time
+        response_time_ms = (time.perf_counter() - start_time) * 1000
+
+        return {
+            "status": "healthy" if server._running else "degraded",
+            "server": {
+                "port": server.port,
+                "test_mode": server.test_mode,
+                "running": server._running,
+                "uptime_seconds": uptime_seconds,
+            },
+            "daemon": daemon_status,
+            "process": process_metrics,
+            "background_tasks": background_tasks,
+            "mcp_servers": mcp_health,
+            # Count of tools from internal gobby-* registries (tasks, memory)
+            "internal_tools_count": internal_tools_count,
+            "sessions": session_stats,
+            "tasks": task_stats,
+            "memory": memory_stats,
+            "plugins": plugin_stats,
+            "response_time_ms": response_time_ms,
+        }
+
+    @router.get("/metrics")
+    async def get_metrics() -> PlainTextResponse:
+        """
+        Prometheus-compatible metrics endpoint.
+
+        Returns metrics in Prometheus text exposition format including:
+        - HTTP request counts and durations
+        - Background task metrics
+        - Daemon health metrics
+        """
+        metrics = get_metrics_collector()
+        try:
+            # Update daemon health metrics if available
+            if server._daemon is not None:
+                try:
+                    uptime = server._daemon.uptime
+                    if uptime is not None:
+                        metrics.set_gauge("daemon_uptime_seconds", uptime)
+
+                    # Get process info for daemon
+                    process = psutil.Process(os.getpid())
+                    memory_info = process.memory_info()
+                    metrics.set_gauge("daemon_memory_usage_bytes", float(memory_info.rss))
+
+                    cpu_percent = process.cpu_percent(interval=0)
+                    metrics.set_gauge("daemon_cpu_percent", cpu_percent)
+                except Exception as e:
+                    logger.warning(f"Failed to update daemon metrics: {e}")
+
+            # Update background task gauge
+            metrics.set_gauge("background_tasks_active", float(len(server._background_tasks)))
+
+            # Export in Prometheus format
+            prometheus_output = metrics.export_prometheus()
+            return PlainTextResponse(
+                content=prometheus_output, media_type="text/plain; version=0.0.4"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to export metrics: {e}", exc_info=True)
+            raise
+
+    @router.get("/config")
+    async def get_config() -> dict[str, Any]:
+        """
+        Get daemon configuration and version information.
+
+        Returns:
+            Configuration data including ports, features, and versions
+        """
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            config_data = {
+                "server": {
+                    "port": server.port,
+                    "test_mode": server.test_mode,
+                    "running": server._running,
+                    "version": get_version(),
+                },
+                "features": {
+                    "session_manager": server.session_manager is not None,
+                    "mcp_manager": server.mcp_manager is not None,
+                },
+                "endpoints": {
+                    "mcp": [
+                        "/mcp/{server_name}/tools/{tool_name}",
+                    ],
+                    "sessions": [
+                        "/sessions/register",
+                        "/sessions/{id}",
+                    ],
+                    "admin": [
+                        "/admin/status",
+                        "/admin/metrics",
+                        "/admin/config",
+                        "/admin/shutdown",
+                    ],
+                },
+            }
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            return {
+                "status": "success",
+                "config": config_data,
+                "response_time_ms": response_time_ms,
+            }
+
+        except Exception as e:
+            logger.error(f"Config retrieval error: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    @router.post("/shutdown")
+    async def shutdown() -> dict[str, Any]:
+        """
+        Graceful daemon shutdown endpoint.
+
+        Returns:
+            Shutdown confirmation
+        """
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+
+        metrics.inc_counter("http_requests_total")
+        metrics.inc_counter("shutdown_requests_total")
+
+        try:
+            logger.debug("Shutdown requested via HTTP endpoint")
+
+            # Create background task for shutdown
+            task = asyncio.create_task(server._process_shutdown())
+
+            server._background_tasks.add(task)
+            task.add_done_callback(server._background_tasks.discard)
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            return {
+                "status": "shutting_down",
+                "message": "Graceful shutdown initiated",
+                "response_time_ms": response_time_ms,
+            }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error("Error initiating shutdown: %s", e, exc_info=True)
+            return {
+                "message": "Shutdown failed to initiate",
+            }
+
+    @router.post("/workflows/reload")
+    async def reload_workflows() -> dict[str, Any]:
+        """
+        Reload workflow definitions from disk.
+
+        Triggers the gobby-workflows.reload_cache MCP tool internally.
+        """
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            # Find the gobby-workflows registry
+            workflows_registry = None
+            if server._internal_manager:
+                for registry in server._internal_manager.get_all_registries():
+                    if registry.name == "gobby-workflows":
+                        workflows_registry = registry
+                        break
+
+            if not workflows_registry:
+                return {
+                    "status": "error",
+                    "message": "Workflow registry not available",
+                }
+
+            # Call reload_cache tool directly via registry.call which handles async/sync
+            try:
+                result = await workflows_registry.call("reload_cache", {})
+            except ValueError:
+                return {
+                    "status": "error",
+                    "message": "reload_cache tool not found",
+                }
+            except Exception as e:
+                logger.error(f"Failed to execute reload_cache: {e}")
+                return {
+                    "status": "error",
+                    "message": f"Failed to reload cache: {e}",
+                }
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            return {
+                "status": "success",
+                "message": "Workflow cache reloaded",
+                "details": result,
+                "response_time_ms": response_time_ms,
+            }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error(f"Error reloading workflows: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    return router

gobby/servers/routes/dependencies.py

@@ -0,0 +1,118 @@
+"""FastAPI dependency injection functions for MCP routes.
+
+These dependencies extract server components from app.state, enabling:
+- Proper testability (dependencies can be mocked/overridden)
+- Clear dependency graph
+- Natural code splitting
+- Standard FastAPI conventions
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from fastapi import HTTPException, Request
+
+if TYPE_CHECKING:
+    from gobby.config.app import DaemonConfig
+    from gobby.llm import LLMService
+    from gobby.mcp_proxy.manager import MCPClientManager
+    from gobby.mcp_proxy.metrics import ToolMetricsManager
+    from gobby.mcp_proxy.registry_manager import InternalToolRegistryManager
+    from gobby.servers.http import HTTPServer
+    from gobby.storage.mcp_db import MCPDatabaseManager
+
+__all__ = [
+    "get_server",
+    "get_mcp_manager",
+    "get_mcp_manager_required",
+    "get_internal_manager",
+    "get_tools_handler",
+    "get_config",
+    "get_mcp_db_manager",
+    "get_llm_service",
+    "get_metrics_manager",
+    "resolve_project_id",
+]
+
+
+async def get_server(request: Request) -> HTTPServer:
+    """Get the HTTPServer instance from app state."""
+    server = getattr(request.app.state, "server", None)
+    if server is None:
+        raise HTTPException(status_code=503, detail="Server not initialized")
+    # Import here to avoid circular import, cast to help mypy
+    from gobby.servers.http import HTTPServer
+
+    return cast(HTTPServer, server)
+
+
+async def get_mcp_manager(request: Request) -> MCPClientManager | None:
+    """Get the MCP client manager for external MCP servers."""
+    server = await get_server(request)
+    return server.mcp_manager
+
+
+async def get_mcp_manager_required(request: Request) -> MCPClientManager:
+    """Get the MCP client manager, raising if unavailable."""
+    manager = await get_mcp_manager(request)
+    if manager is None:
+        raise HTTPException(status_code=503, detail="MCP manager not available")
+    return manager
+
+
+async def get_internal_manager(request: Request) -> InternalToolRegistryManager | None:
+    """Get the internal tool registry manager (gobby-tasks, gobby-memory, etc.)."""
+    server = await get_server(request)
+    return server._internal_manager
+
+
+async def get_tools_handler(request: Request) -> Any:
+    """Get the tools handler for Gobby daemon tools."""
+    server = await get_server(request)
+    return server._tools_handler
+
+
+async def get_config(request: Request) -> DaemonConfig | None:
+    """Get the application configuration."""
+    server = await get_server(request)
+    return server.config
+
+
+async def get_mcp_db_manager(request: Request) -> MCPDatabaseManager | None:
+    """Get the MCP database manager."""
+    server = await get_server(request)
+    return server._mcp_db_manager
+
+
+async def get_llm_service(request: Request) -> LLMService | None:
+    """Get the LLM service for AI-powered operations."""
+    server = await get_server(request)
+    return server.llm_service
+
+
+async def resolve_project_id(request: Request, project_id: str | None = None) -> str:
+    """
+    Resolve a project ID, defaulting to the current project if not specified.
+
+    Args:
+        request: FastAPI request object
+        project_id: Optional explicit project ID
+
+    Returns:
+        Resolved project ID
+
+    Raises:
+        HTTPException: If no project ID can be resolved
+    """
+    server = await get_server(request)
+    resolved = server._resolve_project_id(project_id, cwd=None)
+    if resolved is None:
+        raise HTTPException(status_code=400, detail="No project ID provided or detected")
+    return resolved
+
+
+async def get_metrics_manager(request: Request) -> ToolMetricsManager | None:
+    """Get the tool metrics manager for tracking tool call statistics."""
+    server = await get_server(request)
+    return server.metrics_manager

gobby/servers/routes/mcp/__init__.py

@@ -0,0 +1,24 @@
+"""
+MCP routes package.
+
+Decomposed from monolithic mcp.py using Strangler Fig pattern.
+Each router is now in its own focused module:
+- tools.py: create_mcp_router (tool discovery, execution, search)
+- hooks.py: create_hooks_router (CLI hook adapter)
+- plugins.py: create_plugins_router (plugin management)
+- webhooks.py: create_webhooks_router (webhook management)
+
+This __init__.py re-exports all routers for backward compatibility.
+"""
+
+from gobby.servers.routes.mcp.hooks import create_hooks_router
+from gobby.servers.routes.mcp.plugins import create_plugins_router
+from gobby.servers.routes.mcp.tools import create_mcp_router
+from gobby.servers.routes.mcp.webhooks import create_webhooks_router
+
+__all__ = [
+    "create_hooks_router",
+    "create_mcp_router",
+    "create_plugins_router",
+    "create_webhooks_router",
+]

gobby/servers/routes/mcp/hooks.py

@@ -0,0 +1,135 @@
+"""
+Hooks management routes for Gobby HTTP server.
+
+Provides hook execution endpoint for CLI adapters.
+Extracted from base.py as part of Strangler Fig decomposition.
+"""
+
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, HTTPException, Request
+
+from gobby.utils.metrics import get_metrics_collector
+
+if TYPE_CHECKING:
+    from gobby.servers.http import HTTPServer
+
+logger = logging.getLogger(__name__)
+
+
+def create_hooks_router(server: "HTTPServer") -> APIRouter:
+    """
+    Create hooks router with endpoints bound to server instance.
+
+    Args:
+        server: HTTPServer instance for accessing state and dependencies
+
+    Returns:
+        Configured APIRouter with hooks endpoints
+    """
+    router = APIRouter(prefix="/hooks", tags=["hooks"])
+    metrics = get_metrics_collector()
+
+    @router.post("/execute")
+    async def execute_hook(request: Request) -> dict[str, Any]:
+        """
+        Execute CLI hook via adapter pattern.
+
+        Request body:
+            {
+                "hook_type": "session-start",
+                "input_data": {...},
+                "source": "claude"
+            }
+
+        Returns:
+            Hook execution result with status
+        """
+        start_time = time.perf_counter()
+        metrics.inc_counter("http_requests_total")
+        metrics.inc_counter("hooks_total")
+
+        try:
+            # Parse request
+            payload = await request.json()
+            hook_type = payload.get("hook_type")
+            source = payload.get("source")
+
+            if not hook_type:
+                raise HTTPException(status_code=400, detail="hook_type required")
+
+            if not source:
+                raise HTTPException(status_code=400, detail="source required")
+
+            # Get HookManager from app.state
+            if not hasattr(request.app.state, "hook_manager"):
+                raise HTTPException(status_code=503, detail="HookManager not initialized")
+
+            hook_manager = request.app.state.hook_manager
+
+            # Select adapter based on source
+            from gobby.adapters.base import BaseAdapter
+            from gobby.adapters.claude_code import ClaudeCodeAdapter
+            from gobby.adapters.codex import CodexNotifyAdapter
+            from gobby.adapters.gemini import GeminiAdapter
+
+            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 == "gemini":
+                adapter = GeminiAdapter(hook_manager=hook_manager)
+            elif source == "codex":
+                adapter = CodexNotifyAdapter(hook_manager=hook_manager)
+            else:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Unsupported source: {source}. Supported: claude, antigravity, gemini, codex",
+                )
+
+            # Execute hook via adapter
+            try:
+                result = await asyncio.to_thread(adapter.handle_native, payload, hook_manager)
+
+                response_time_ms = (time.perf_counter() - start_time) * 1000
+                metrics.inc_counter("hooks_succeeded_total")
+
+                logger.debug(
+                    f"Hook executed: {hook_type}",
+                    extra={
+                        "hook_type": hook_type,
+                        "continue": result.get("continue"),
+                        "response_time_ms": response_time_ms,
+                    },
+                )
+
+                return result
+
+            except ValueError as e:
+                metrics.inc_counter("hooks_failed_total")
+                logger.warning(
+                    f"Invalid hook request: {hook_type}",
+                    extra={"hook_type": hook_type, "error": str(e)},
+                )
+                raise HTTPException(status_code=400, detail=str(e)) from e
+
+            except Exception as e:
+                metrics.inc_counter("hooks_failed_total")
+                logger.error(
+                    f"Hook execution failed: {hook_type}",
+                    exc_info=True,
+                    extra={"hook_type": hook_type},
+                )
+                raise HTTPException(status_code=500, detail=str(e)) from e
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            metrics.inc_counter("hooks_failed_total")
+            logger.error("Hook endpoint error", exc_info=True)
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    return router