gobby 0.2.5__py3-none-any.whl

gobby/servers/http.py

@@ -0,0 +1,636 @@
+"""
+HTTP server for Gobby daemon.
+
+Provides a FastAPI-based HTTP server for REST endpoints, MCP tool proxying,
+and session management. Local-first version: no platform auth, no remote sync.
+"""
+
+import asyncio
+import logging
+import time
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from gobby.adapters.codex import CodexAdapter
+from gobby.hooks.broadcaster import HookEventBroadcaster
+from gobby.hooks.hook_manager import HookManager
+from gobby.llm import LLMService, create_llm_service
+from gobby.mcp_proxy.registries import setup_internal_registries
+from gobby.mcp_proxy.semantic_search import SemanticToolSearch
+from gobby.mcp_proxy.server import GobbyDaemonTools, create_mcp_server
+from gobby.mcp_proxy.services.tool_filter import ToolFilterService
+from gobby.memory.manager import MemoryManager
+
+# Re-export for backward compatibility
+from gobby.servers.models import SessionRegisterRequest  # noqa: F401
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks import LocalTaskManager
+from gobby.sync.tasks import TaskSyncManager
+from gobby.utils.metrics import get_metrics_collector
+from gobby.utils.version import get_version
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPServer:
+    """
+    FastAPI HTTP server for Gobby daemon.
+
+    Handles MCP tool proxying, session management, and admin endpoints.
+    Local-first version: no platform authentication, uses local SQLite storage.
+    """
+
+    def __init__(
+        self,
+        port: int = 8000,
+        test_mode: bool = False,
+        mcp_manager: Any | None = None,
+        mcp_db_manager: Any | None = None,
+        config: Any | None = None,
+        codex_client: Any | None = None,
+        session_manager: LocalSessionManager | None = None,
+        websocket_server: Any | None = None,
+        task_manager: LocalTaskManager | None = None,
+        task_sync_manager: TaskSyncManager | None = None,
+        message_processor: Any | None = None,
+        message_manager: Any | None = None,  # LocalSessionMessageManager
+        memory_manager: "MemoryManager | None" = None,
+        llm_service: "LLMService | None" = None,
+        memory_sync_manager: Any | None = None,
+        task_expander: Any | None = None,
+        task_validator: Any | None = None,
+        metrics_manager: Any | None = None,
+        agent_runner: Any | None = None,
+        worktree_storage: Any | None = None,
+    ) -> None:
+        """
+        Initialize HTTP server.
+
+        Args:
+            port: Server port
+            test_mode: Run in test mode (disable features that conflict with testing)
+            mcp_manager: MCPClientManager instance for multi-server support
+            mcp_db_manager: LocalMCPManager instance for SQLite-based storage of MCP
+                server configurations and tool schemas. Used by ToolsHandler for
+                progressive tool discovery. Optional; defaults to None.
+            config: DaemonConfig instance for configuration
+            codex_client: CodexAppServerClient instance for Codex integration
+            session_manager: LocalSessionManager for session storage
+            websocket_server: Optional WebSocketServer instance for event broadcasting
+            task_manager: LocalTaskManager instance
+            task_sync_manager: TaskSyncManager instance
+            message_processor: SessionMessageProcessor instance
+            message_manager: LocalSessionMessageManager instance for retrieval
+            memory_manager: MemoryManager instance
+            llm_service: LLMService instance
+        """
+        self.port = port
+        self.test_mode = test_mode
+        self.mcp_manager = mcp_manager
+        self.config = config
+        self.codex_client = codex_client
+        self.session_manager = session_manager
+        self.task_manager = task_manager
+        self.task_sync_manager = task_sync_manager
+        self.message_processor = message_processor
+        self.message_manager = message_manager
+        self.memory_manager = memory_manager
+        self.websocket_server = websocket_server
+        self.llm_service = llm_service
+        self.memory_sync_manager = memory_sync_manager
+        self.task_expander = task_expander
+        self.task_validator = task_validator
+        self.metrics_manager = metrics_manager
+        self.agent_runner = agent_runner
+        self.worktree_storage = worktree_storage
+
+        # Initialize WebSocket broadcaster
+        # Note: websocket_server might be None if disabled
+        self.broadcaster = HookEventBroadcaster(websocket_server, config)
+
+        self._start_time: float = time.time()
+
+        # Create LLM service if not provided
+        if not self.llm_service and config:
+            try:
+                self.llm_service = create_llm_service(config)
+                logger.debug(
+                    f"LLM service initialized with providers: {self.llm_service.enabled_providers}"
+                )
+            except Exception as e:
+                logger.error(f"Failed to initialize LLM service: {e}")
+
+        # Create MCP server instance
+        self._mcp_server = None
+        self._internal_manager = None
+        self._tools_handler = None
+        self._mcp_db_manager = mcp_db_manager
+        if mcp_manager:
+            # Determine WebSocket port
+            ws_port = 8766
+            if config and hasattr(config, "websocket") and config.websocket:
+                ws_port = config.websocket.port
+
+            # Create a lazy getter for tool_proxy that will be available after
+            # GobbyDaemonTools is created. This allows in-process agents to route
+            # tool calls through the MCP proxy.
+            def tool_proxy_getter() -> Any:
+                if self._tools_handler is not None:
+                    return self._tools_handler.tool_proxy
+                return None
+
+            # Create merge managers if db available
+            merge_storage = None
+            merge_resolver = None
+            if mcp_db_manager:
+                from gobby.storage.merge_resolutions import MergeResolutionManager
+                from gobby.worktrees.merge.resolver import MergeResolver
+
+                merge_storage = MergeResolutionManager(mcp_db_manager.db)
+                merge_resolver = MergeResolver()
+                merge_resolver._llm_service = self.llm_service
+                logger.debug("Merge resolution subsystems initialized")
+
+            # Setup internal registries (gobby-tasks, gobby-memory, etc.)
+            self._internal_manager = setup_internal_registries(
+                _config=config,
+                _session_manager=None,  # Not needed for internal registries
+                memory_manager=memory_manager,
+                task_manager=task_manager,
+                sync_manager=task_sync_manager,
+                task_expander=self.task_expander,
+                task_validator=self.task_validator,
+                message_manager=message_manager,
+                local_session_manager=session_manager,
+                metrics_manager=self.metrics_manager,
+                llm_service=self.llm_service,
+                agent_runner=self.agent_runner,
+                worktree_storage=self.worktree_storage,
+                git_manager=None,  # Created per-project, not at daemon startup
+                merge_storage=merge_storage,
+                merge_resolver=merge_resolver,
+                project_id=None,  # Project-specific, not global
+                tool_proxy_getter=tool_proxy_getter,
+            )
+            registry_count = len(self._internal_manager)
+            logger.debug(f"Internal registries initialized: {registry_count} registries")
+
+            # Initialize tool summarizer config
+            if config:
+                from gobby.tools.summarizer import init_summarizer_config
+
+                init_summarizer_config(config.tool_summarizer)
+                logger.debug("Tool summarizer config initialized")
+
+            # Create semantic search instance if db available
+            semantic_search = None
+            if mcp_db_manager:
+                semantic_search = SemanticToolSearch(db=mcp_db_manager.db)
+                logger.debug("Semantic tool search initialized")
+
+            # Create tool filter for workflow phase restrictions
+            tool_filter = None
+            if mcp_db_manager:
+                tool_filter = ToolFilterService(db=mcp_db_manager.db)
+                logger.debug("Tool filter service initialized")
+
+            # Create fallback resolver for alternative tool suggestions on error
+            fallback_resolver = None
+            if semantic_search and self.metrics_manager:
+                from gobby.mcp_proxy.services.fallback import ToolFallbackResolver
+
+                fallback_resolver = ToolFallbackResolver(
+                    semantic_search=semantic_search,
+                    metrics_manager=self.metrics_manager,
+                )
+                logger.debug("Fallback resolver initialized")
+
+            # Create tools handler
+            self._tools_handler = GobbyDaemonTools(
+                mcp_manager=mcp_manager,
+                daemon_port=port,
+                websocket_port=ws_port,
+                start_time=self._start_time,
+                internal_manager=self._internal_manager,
+                config=config,
+                llm_service=self.llm_service,
+                session_manager=session_manager,
+                memory_manager=memory_manager,
+                config_manager=mcp_db_manager,
+                semantic_search=semantic_search,
+                tool_filter=tool_filter,
+                fallback_resolver=fallback_resolver,
+            )
+            self._mcp_server = create_mcp_server(self._tools_handler)
+            logger.debug("MCP server initialized and will be mounted at /mcp")
+
+        self.app = self._create_app()
+        self._running = False
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._metrics = get_metrics_collector()
+        self._daemon: Any = None  # Set externally by daemon
+
+    def _resolve_project_id(self, project_id: str | None, cwd: str | None) -> str:
+        """
+        Resolve project_id from cwd if not provided.
+
+        If project_id is given, returns it directly.
+        Otherwise, looks up project from .gobby/project.json in the cwd.
+
+        Args:
+            project_id: Optional explicit project ID
+            cwd: Current working directory path
+
+        Returns:
+            Project ID from .gobby/project.json
+
+        Raises:
+            ValueError: If no project.json found (project not initialized)
+        """
+        from pathlib import Path
+
+        if project_id:
+            return project_id
+
+        # Get cwd or use current directory
+        working_dir = Path(cwd) if cwd else Path.cwd()
+
+        # Look up project from .gobby/project.json
+        from gobby.utils.project_context import get_project_context
+
+        project_context = get_project_context(working_dir)
+        if project_context and project_context.get("id"):
+            return str(project_context["id"])
+
+        # No project.json found - require explicit initialization
+        raise ValueError(
+            f"No .gobby/project.json found in {working_dir} or parents. "
+            "Run 'gobby init' to initialize a project."
+        )
+
+    def _create_app(self) -> FastAPI:
+        """
+        Create and configure FastAPI application.
+
+        Returns:
+            Configured FastAPI app instance
+        """
+
+        # Create MCP app first if available (needed for lifespan)
+        mcp_app = None
+        if self._mcp_server:
+            mcp_app = self._mcp_server.streamable_http_app()
+            logger.debug("MCP HTTP app created")
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncGenerator[None]:
+            """Handle application startup and shutdown with combined lifespans."""
+            logger.debug("Starting Gobby HTTP server on port %d", self.port)
+            self._running = True
+            self._start_time = time.time()
+
+            # Startup operations
+            if self.test_mode:
+                logger.debug("Running in test mode - external connections disabled")
+
+            # Initialize HookManager singleton with logging config
+            hook_manager_kwargs: dict[str, Any] = {
+                "daemon_host": "localhost",
+                "daemon_port": self.port,
+                "llm_service": self.llm_service,
+                "config": self.config,
+                "broadcaster": self.broadcaster,
+                "mcp_manager": self.mcp_manager,
+                "message_processor": self.message_processor,
+                "memory_sync_manager": self.memory_sync_manager,
+                "task_sync_manager": self.task_sync_manager,
+            }
+            if self.config:
+                # Pass full log file path from config
+                hook_manager_kwargs["log_file"] = self.config.logging.hook_manager
+                hook_manager_kwargs["log_max_bytes"] = self.config.logging.max_size_mb * 1024 * 1024
+                hook_manager_kwargs["log_backup_count"] = self.config.logging.backup_count
+
+                app.state.hook_manager = HookManager(**hook_manager_kwargs)
+            logger.debug("HookManager initialized in daemon")
+
+            # Wire up stop_registry to WebSocket server for stop_request handling
+            if (
+                self.websocket_server
+                and hasattr(app.state, "hook_manager")
+                and hasattr(app.state.hook_manager, "_stop_registry")
+            ):
+                self.websocket_server.stop_registry = app.state.hook_manager._stop_registry
+                logger.debug("Stop registry connected to WebSocket server")
+
+            # Store server instance for dependency injection
+            app.state.server = self
+
+            # Initialize CodexAdapter for session tracking
+            app.state.codex_adapter = None
+            if self.codex_client and CodexAdapter.is_codex_available():
+                codex_adapter = CodexAdapter(hook_manager=app.state.hook_manager)
+                codex_adapter.attach_to_client(self.codex_client)
+                app.state.codex_adapter = codex_adapter
+                logger.debug("CodexAdapter attached to CodexAppServerClient")
+
+                # Sync existing Codex sessions when client is connected
+                if self.codex_client.is_connected:
+                    try:
+                        synced = await codex_adapter.sync_existing_sessions()
+                        logger.debug(f"Synced {synced} existing Codex sessions")
+                    except Exception as e:
+                        logger.warning(f"Failed to sync existing Codex sessions: {e}")
+
+            # If MCP app exists, wrap its lifespan
+            if mcp_app is not None:
+                # Use router.lifespan_context for stable FastMCP version
+                async with mcp_app.router.lifespan_context(app):
+                    logger.debug("MCP server lifespan initialized")
+                    yield
+                logger.debug("MCP server lifespan shutdown complete")
+            else:
+                yield
+
+            # Shutdown operations
+            logger.debug("Shutting down Gobby HTTP server")
+
+            # Cleanup CodexAdapter
+            if hasattr(app.state, "codex_adapter") and app.state.codex_adapter:
+                app.state.codex_adapter.detach_from_client()
+                logger.debug("CodexAdapter detached")
+
+            # Cleanup HookManager
+            if hasattr(app.state, "hook_manager"):
+                app.state.hook_manager.shutdown()
+                logger.debug("HookManager shutdown complete")
+
+            # Process graceful shutdown (tasks, MCP connections)
+            await self._process_shutdown()
+
+            self._running = False
+
+        app = FastAPI(
+            title="Gobby Daemon",
+            description="Local-first HTTP server for MCP and session management",
+            version=get_version(),
+            lifespan=lifespan,
+        )
+
+        # Add CORS middleware for cross-origin requests
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],  # Allow all origins for local development
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        # Register exception handlers
+        self._register_exception_handlers(app)
+
+        # Register routes
+        self._register_routes(app)
+
+        # Mount MCP server if available
+        if mcp_app is not None:
+            app.mount("/mcp", mcp_app)
+            logger.debug("MCP server mounted at /mcp")
+
+        return app
+
+    def _register_exception_handlers(self, app: FastAPI) -> None:
+        """
+        Register global exception handlers.
+
+        All exceptions return 200 OK to prevent Claude Code hook failures.
+
+        Args:
+            app: FastAPI application instance
+        """
+
+        @app.exception_handler(Exception)
+        async def global_exception_handler(
+            request: Request,
+            exc: Exception,
+        ) -> JSONResponse:
+            """Handle all uncaught exceptions.
+
+            HTTPException is re-raised to let FastAPI's built-in handler
+            return proper status codes (404, 422, etc.). All other exceptions
+            return 200 OK to prevent hook failures.
+            """
+            # Let HTTPException pass through to FastAPI's built-in handler
+            # so proper status codes (404, 422, etc.) are returned
+            if isinstance(exc, HTTPException):
+                raise exc
+
+            logger.error(
+                "Unhandled exception in HTTP server: %s",
+                exc,
+                exc_info=True,
+                extra={
+                    "path": request.url.path,
+                    "method": request.method,
+                    "client": request.client.host if request.client else None,
+                },
+            )
+
+            # Return 200 OK to prevent hook failure for non-HTTP exceptions
+            return JSONResponse(
+                status_code=200,
+                content={
+                    "status": "error",
+                    "message": "Internal error occurred but request acknowledged",
+                    "error_logged": True,
+                },
+            )
+
+    def _register_routes(self, app: FastAPI) -> None:
+        """
+        Register HTTP routes using extracted router modules.
+
+        Args:
+            app: FastAPI application instance
+        """
+        from gobby.servers.routes import (
+            create_admin_router,
+            create_hooks_router,
+            create_mcp_router,
+            create_plugins_router,
+            create_sessions_router,
+            create_webhooks_router,
+        )
+
+        # Include all routers
+        app.include_router(create_admin_router(self))
+        app.include_router(create_sessions_router(self))
+        app.include_router(create_mcp_router())
+        app.include_router(create_hooks_router(self))
+        app.include_router(create_plugins_router())
+        app.include_router(create_webhooks_router())
+
+    async def _process_shutdown(self) -> None:
+        """
+        Background task to perform graceful daemon shutdown.
+        """
+        start_time = time.perf_counter()
+
+        try:
+            logger.debug("Processing graceful shutdown")
+
+            # Wait for pending background tasks to complete
+            pending_tasks_count = len(self._background_tasks)
+            if pending_tasks_count > 0:
+                logger.debug(
+                    "Waiting for pending background tasks to complete",
+                    extra={"pending_tasks": pending_tasks_count},
+                )
+
+                max_wait = 30.0
+                wait_start = time.perf_counter()
+
+                while (
+                    len(self._background_tasks) > 0
+                    and (time.perf_counter() - wait_start) < max_wait
+                ):
+                    await asyncio.sleep(0.5)
+
+                completed_wait = time.perf_counter() - wait_start
+                remaining_tasks = len(self._background_tasks)
+
+                if remaining_tasks > 0:
+                    logger.warning(
+                        "Shutdown timeout - some background tasks still pending",
+                        extra={
+                            "remaining_tasks": remaining_tasks,
+                            "wait_seconds": completed_wait,
+                        },
+                    )
+                else:
+                    logger.debug(
+                        "All background tasks completed",
+                        extra={"wait_seconds": completed_wait},
+                    )
+
+            # Disconnect all MCP servers
+            if self.mcp_manager:
+                logger.debug("Disconnecting MCP servers...")
+                try:
+                    await self.mcp_manager.disconnect_all()
+                    logger.debug("MCP servers disconnected")
+                except Exception as e:
+                    logger.warning(f"Error disconnecting MCP servers: {e}")
+
+            duration_seconds = time.perf_counter() - start_time
+            self._metrics.inc_counter("shutdown_succeeded_total")
+
+            logger.debug(
+                "Shutdown processed",
+                extra={"duration_seconds": duration_seconds},
+            )
+
+        except Exception as e:
+            duration_seconds = time.perf_counter() - start_time
+            self._metrics.inc_counter("shutdown_failed_total")
+
+            logger.error(
+                "Shutdown processing failed: %s",
+                e,
+                exc_info=True,
+                extra={"duration_seconds": duration_seconds},
+            )
+
+
+async def create_server(
+    port: int = 8765,
+    test_mode: bool = False,
+    mcp_manager: Any | None = None,
+    config: Any | None = None,
+    session_manager: LocalSessionManager | None = None,
+) -> HTTPServer:
+    """
+    Create HTTP server instance.
+
+    Args:
+        port: Port to listen on
+        test_mode: Enable test mode
+        mcp_manager: MCP client manager
+        config: Daemon configuration
+        session_manager: Local session manager
+
+    Returns:
+        Configured HTTPServer instance
+    """
+    return HTTPServer(
+        port=port,
+        test_mode=test_mode,
+        mcp_manager=mcp_manager,
+        config=config,
+        session_manager=session_manager,
+    )
+
+
+async def run_server(
+    server: HTTPServer,
+    host: str = "0.0.0.0",  # nosec B104 - local daemon needs network access
+    workers: int = 1,
+    limit_concurrency: int | None = 1000,
+    limit_max_requests: int | None = None,
+    timeout_keep_alive: int = 5,
+    timeout_graceful_shutdown: int = 30,
+) -> None:
+    """
+    Run HTTP server with production-ready Uvicorn configuration.
+
+    Args:
+        server: HTTPServer instance
+        host: Host to bind to (default: 0.0.0.0 for all interfaces)
+        workers: Number of worker processes (default: 1 for async)
+        limit_concurrency: Max concurrent connections (default: 1000)
+        limit_max_requests: Max requests before worker restart (None = unlimited)
+        timeout_keep_alive: Keep-alive timeout in seconds (default: 5)
+        timeout_graceful_shutdown: Graceful shutdown timeout in seconds (default: 30)
+    """
+    import uvicorn
+
+    config = uvicorn.Config(
+        server.app,
+        host=host,
+        port=server.port,
+        log_level="info",
+        access_log=True,
+        log_config=None,
+        limit_concurrency=limit_concurrency,
+        limit_max_requests=limit_max_requests,
+        timeout_keep_alive=timeout_keep_alive,
+        timeout_graceful_shutdown=timeout_graceful_shutdown,
+        backlog=2048,
+        workers=workers,
+        loop="auto",
+        h11_max_incomplete_event_size=16384,
+    )
+
+    uvicorn_server = uvicorn.Server(config)
+
+    async def shutdown_handler() -> None:
+        """Handle graceful shutdown of HTTP server."""
+        logger.debug("Initiating HTTP server shutdown...")
+        if hasattr(server, "_daemon") and server._daemon is not None:
+            try:
+                server._daemon.graceful_shutdown(timeout=timeout_graceful_shutdown)
+            except Exception as e:
+                logger.warning(f"Error during daemon shutdown: {e}")
+
+    try:
+        await uvicorn_server.serve()
+    except (KeyboardInterrupt, SystemExit):
+        logger.debug("Received shutdown signal")
+        await shutdown_handler()
+    finally:
+        logger.debug("HTTP server stopped")

gobby/servers/models.py

@@ -0,0 +1,31 @@
+"""
+Pydantic models for HTTP server request/response schemas.
+"""
+
+from pydantic import BaseModel, Field
+
+
+class SessionRegisterRequest(BaseModel):
+    """Request model for session registration endpoint."""
+
+    external_id: str = Field(
+        ..., description="External session identifier (e.g., from Claude Code)"
+    )
+    machine_id: str | None = Field(None, description="Unique machine identifier")
+
+    # Session metadata
+    jsonl_path: str | None = Field(None, description="Path to JSONL transcript file")
+    title: str | None = Field(None, description="Natural language session summary/title")
+    source: str | None = Field(
+        None, description="Session source (e.g., 'Claude Code', 'Agent SDK')"
+    )
+    parent_session_id: str | None = Field(
+        None, description="Parent session ID for session lineage tracking"
+    )
+    status: str | None = Field(None, description="Session status (active, paused, etc.)")
+    project_id: str | None = Field(None, description="Project ID to associate with session")
+    project_path: str | None = Field(
+        None, description="Project root directory path (for git extraction)"
+    )
+    git_branch: str | None = Field(None, description="Current git branch name")
+    cwd: str | None = Field(None, description="Current working directory")

gobby/servers/routes/__init__.py

@@ -0,0 +1,23 @@
+"""
+FastAPI route modules for Gobby HTTP server.
+
+Each module contains an APIRouter with related endpoints.
+"""
+
+from gobby.servers.routes.admin import create_admin_router
+from gobby.servers.routes.mcp import (
+    create_hooks_router,
+    create_mcp_router,
+    create_plugins_router,
+    create_webhooks_router,
+)
+from gobby.servers.routes.sessions import create_sessions_router
+
+__all__ = [
+    "create_admin_router",
+    "create_hooks_router",
+    "create_mcp_router",
+    "create_plugins_router",
+    "create_sessions_router",
+    "create_webhooks_router",
+]