gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/servers/http.py

@@ -16,7 +16,7 @@ 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.adapters.codex_impl.adapter import CodexAdapter
 from gobby.hooks.broadcaster import HookEventBroadcaster
 from gobby.hooks.hook_manager import HookManager
 from gobby.llm import LLMService, create_llm_service
@@ -25,9 +25,6 @@ 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
@@ -62,11 +59,13 @@ class HTTPServer:
         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,
+        clone_storage: Any | None = None,
+        git_manager: Any | None = None,
+        project_id: str | None = None,
     ) -> None:
         """
         Initialize HTTP server.
@@ -103,11 +102,13 @@ class HTTPServer:
         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
+        self.clone_storage = clone_storage
+        self.git_manager = git_manager
+        self.project_id = project_id
 
         # Initialize WebSocket broadcaster
         # Note: websocket_server might be None if disabled
@@ -132,7 +133,7 @@ class HTTPServer:
         self._mcp_db_manager = mcp_db_manager
         if mcp_manager:
             # Determine WebSocket port
-            ws_port = 8766
+            ws_port = 60888
             if config and hasattr(config, "websocket") and config.websocket:
                 ws_port = config.websocket.port
 
@@ -147,14 +148,17 @@ class HTTPServer:
             # Create merge managers if db available
             merge_storage = None
             merge_resolver = None
+            inter_session_message_manager = None
             if mcp_db_manager:
+                from gobby.storage.inter_session_messages import InterSessionMessageManager
                 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")
+                inter_session_message_manager = InterSessionMessageManager(mcp_db_manager.db)
+                logger.debug("Merge resolution and inter-session messaging subsystems initialized")
 
             # Setup internal registries (gobby-tasks, gobby-memory, etc.)
             self._internal_manager = setup_internal_registries(
@@ -163,7 +167,6 @@ class HTTPServer:
                 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,
@@ -171,11 +174,13 @@ class HTTPServer:
                 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
+                clone_storage=self.clone_storage,
+                git_manager=self.git_manager,
                 merge_storage=merge_storage,
                 merge_resolver=merge_resolver,
-                project_id=None,  # Project-specific, not global
+                project_id=self.project_id,
                 tool_proxy_getter=tool_proxy_getter,
+                inter_session_message_manager=inter_session_message_manager,
             )
             registry_count = len(self._internal_manager)
             logger.debug(f"Internal registries initialized: {registry_count} registries")
@@ -235,6 +240,13 @@ class HTTPServer:
         self._metrics = get_metrics_collector()
         self._daemon: Any = None  # Set externally by daemon
 
+    @property
+    def tool_proxy(self) -> Any:
+        """Get the ToolProxyService instance for routing tool calls with error enrichment."""
+        if self._tools_handler is not None:
+            return self._tools_handler.tool_proxy
+        return None
+
     def _resolve_project_id(self, project_id: str | None, cwd: str | None) -> str:
         """
         Resolve project_id from cwd if not provided.
@@ -548,7 +560,7 @@ class HTTPServer:
 
 
 async def create_server(
-    port: int = 8765,
+    port: int = 60887,
     test_mode: bool = False,
     mcp_manager: Any | None = None,
     config: Any | None = None,

gobby/servers/routes/admin.py

@@ -13,6 +13,7 @@ from typing import TYPE_CHECKING, Any
 import psutil
 from fastapi import APIRouter
 from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel
 
 from gobby.utils.metrics import Counter, get_metrics_collector
 from gobby.utils.version import get_version
@@ -174,6 +175,19 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             except Exception as e:
                 logger.warning(f"Failed to get memory stats: {e}")
 
+        # Get skills statistics
+        skills_stats: dict[str, Any] = {"total": 0}
+        if server._internal_manager:
+            try:
+                for registry in server._internal_manager.get_all_registries():
+                    if registry.name == "gobby-skills":
+                        result = await registry.call("list_skills", {"limit": 10000})
+                        if result.get("success"):
+                            skills_stats["total"] = result.get("count", 0)
+                        break
+            except Exception as e:
+                logger.warning(f"Failed to get skills 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:
@@ -217,6 +231,7 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
             "sessions": session_stats,
             "tasks": task_stats,
             "memory": memory_stats,
+            "skills": skills_stats,
             "plugins": plugin_stats,
             "response_time_ms": response_time_ms,
         }
@@ -413,4 +428,283 @@ def create_admin_router(server: "HTTPServer") -> APIRouter:
 
             raise HTTPException(status_code=500, detail=str(e)) from e
 
+    # --- Test endpoints (for E2E testing) ---
+
+    class TestProjectRegisterRequest(BaseModel):
+        """Request model for registering a test project."""
+
+        project_id: str
+        name: str
+        repo_path: str | None = None
+
+    @router.post("/test/register-project")
+    async def register_test_project(request: TestProjectRegisterRequest) -> dict[str, Any]:
+        """
+        Register a test project in the database.
+
+        This endpoint is for E2E testing. It ensures the project exists
+        in the projects table so sessions can be created with valid project_ids.
+
+        Args:
+            request: Project registration details
+
+        Returns:
+            Registration confirmation
+        """
+        from fastapi import HTTPException
+
+        from gobby.storage.projects import LocalProjectManager
+
+        # Guard: Only available in test mode
+        if not server.test_mode:
+            raise HTTPException(
+                status_code=403, detail="Test endpoints only available in test mode"
+            )
+
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            # Use server's session manager database to avoid creating separate connections
+            if server.session_manager is None:
+                raise HTTPException(status_code=503, detail="Session manager not available")
+
+            db = server.session_manager.db
+
+            project_manager = LocalProjectManager(db)
+
+            # Check if project exists
+            existing = project_manager.get(request.project_id)
+            if existing:
+                return {
+                    "status": "already_exists",
+                    "project_id": existing.id,
+                    "name": existing.name,
+                }
+
+            # Create the project with the specific ID
+            from datetime import UTC, datetime
+
+            now = datetime.now(UTC).isoformat()
+            db.execute(
+                """
+                INSERT INTO projects (id, name, repo_path, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (request.project_id, request.name, request.repo_path, now, now),
+            )
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            return {
+                "status": "success",
+                "message": f"Registered test project {request.project_id}",
+                "project_id": request.project_id,
+                "name": request.name,
+                "response_time_ms": response_time_ms,
+            }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error(f"Error registering test project: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    class TestAgentRegisterRequest(BaseModel):
+        """Request model for registering a test agent."""
+
+        run_id: str
+        session_id: str
+        parent_session_id: str
+        mode: str = "terminal"
+
+    @router.post("/test/register-agent")
+    async def register_test_agent(request: TestAgentRegisterRequest) -> dict[str, Any]:
+        """
+        Register a test agent in the running agent registry.
+
+        This endpoint is for E2E testing of inter-agent messaging.
+        It allows tests to set up parent-child agent relationships
+        without actually spawning agent processes.
+
+        Args:
+            request: Agent registration details
+
+        Returns:
+            Registration confirmation
+        """
+        from fastapi import HTTPException
+
+        from gobby.agents.registry import RunningAgent, get_running_agent_registry
+
+        # Guard: Only available in test mode
+        if not server.test_mode:
+            raise HTTPException(
+                status_code=403, detail="Test endpoints only available in test mode"
+            )
+
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            registry = get_running_agent_registry()
+
+            # Create and register the agent
+            running_agent = RunningAgent(
+                run_id=request.run_id,
+                session_id=request.session_id,
+                parent_session_id=request.parent_session_id,
+                mode=request.mode,
+            )
+            registry.add(running_agent)
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            return {
+                "status": "success",
+                "message": f"Registered test agent {request.run_id}",
+                "agent": running_agent.to_dict(),
+                "response_time_ms": response_time_ms,
+            }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error(f"Error registering test agent: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    @router.delete("/test/unregister-agent/{run_id}")
+    async def unregister_test_agent(run_id: str) -> dict[str, Any]:
+        """
+        Unregister a test agent from the running agent registry.
+
+        Args:
+            run_id: The agent run ID to remove
+
+        Returns:
+            Unregistration confirmation
+        """
+        from fastapi import HTTPException
+
+        from gobby.agents.registry import get_running_agent_registry
+
+        # Guard: Only available in test mode
+        if not server.test_mode:
+            raise HTTPException(
+                status_code=403, detail="Test endpoints only available in test mode"
+            )
+
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            registry = get_running_agent_registry()
+            agent = registry.remove(run_id)
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            if agent:
+                return {
+                    "status": "success",
+                    "message": f"Unregistered test agent {run_id}",
+                    "response_time_ms": response_time_ms,
+                }
+            else:
+                return {
+                    "status": "not_found",
+                    "message": f"Agent {run_id} not found in registry",
+                    "response_time_ms": response_time_ms,
+                }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error(f"Error unregistering test agent: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
+    class TestSessionUsageRequest(BaseModel):
+        """Request body for setting test session usage."""
+
+        session_id: str
+        input_tokens: int = 0
+        output_tokens: int = 0
+        cache_creation_tokens: int = 0
+        cache_read_tokens: int = 0
+        total_cost_usd: float = 0.0
+
+    @router.post("/test/set-session-usage")
+    async def set_test_session_usage(request: TestSessionUsageRequest) -> dict[str, Any]:
+        """
+        Set usage statistics for a test session.
+
+        This endpoint is for E2E testing of token budget throttling.
+        It allows tests to set session usage values to simulate
+        budget consumption.
+
+        Args:
+            request: Session usage details
+
+        Returns:
+            Update confirmation
+        """
+        from fastapi import HTTPException
+
+        # Guard: Only available in test mode
+        if not server.test_mode:
+            raise HTTPException(
+                status_code=403, detail="Test endpoints only available in test mode"
+            )
+
+        start_time = time.perf_counter()
+        metrics = get_metrics_collector()
+        metrics.inc_counter("http_requests_total")
+
+        try:
+            if server.session_manager is None:
+                raise HTTPException(status_code=503, detail="Session manager not available")
+
+            success = server.session_manager.update_usage(
+                session_id=request.session_id,
+                input_tokens=request.input_tokens,
+                output_tokens=request.output_tokens,
+                cache_creation_tokens=request.cache_creation_tokens,
+                cache_read_tokens=request.cache_read_tokens,
+                total_cost_usd=request.total_cost_usd,
+            )
+
+            response_time_ms = (time.perf_counter() - start_time) * 1000
+
+            if success:
+                return {
+                    "status": "success",
+                    "session_id": request.session_id,
+                    "usage_set": {
+                        "input_tokens": request.input_tokens,
+                        "output_tokens": request.output_tokens,
+                        "cache_creation_tokens": request.cache_creation_tokens,
+                        "cache_read_tokens": request.cache_read_tokens,
+                        "total_cost_usd": request.total_cost_usd,
+                    },
+                    "response_time_ms": response_time_ms,
+                }
+            else:
+                return {
+                    "status": "not_found",
+                    "message": f"Session {request.session_id} not found",
+                    "response_time_ms": response_time_ms,
+                }
+
+        except Exception as e:
+            metrics.inc_counter("http_requests_errors_total")
+            logger.error(f"Error setting test session usage: {e}", exc_info=True)
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=500, detail=str(e)) from e
+
     return router

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

@@ -0,0 +1,61 @@
+"""
+MCP endpoint modules for the Gobby HTTP server.
+
+This package contains decomposed endpoint handlers extracted from tools.py
+using the Strangler Fig pattern. Each module handles a specific domain:
+
+- discovery: Tool and server listing endpoints
+- execution: Tool invocation endpoints
+- server: Server management (add/remove/import)
+- registry: Tool embedding, status, and refresh
+
+External modules should import `create_mcp_router` from the parent package:
+    from gobby.servers.routes.mcp import create_mcp_router
+
+For direct endpoint access (e.g., testing), import from submodules:
+    from gobby.servers.routes.mcp.endpoints.discovery import list_all_mcp_tools
+"""
+
+from gobby.servers.routes.mcp.endpoints.discovery import (
+    list_all_mcp_tools,
+    recommend_mcp_tools,
+    search_mcp_tools,
+)
+from gobby.servers.routes.mcp.endpoints.execution import (
+    call_mcp_tool,
+    get_tool_schema,
+    list_mcp_tools,
+    mcp_proxy,
+)
+from gobby.servers.routes.mcp.endpoints.registry import (
+    embed_mcp_tools,
+    get_mcp_status,
+    refresh_mcp_tools,
+)
+from gobby.servers.routes.mcp.endpoints.server import (
+    add_mcp_server,
+    import_mcp_server,
+    list_mcp_servers,
+    remove_mcp_server,
+)
+
+__all__ = [
+    # Discovery
+    "list_all_mcp_tools",
+    "recommend_mcp_tools",
+    "search_mcp_tools",
+    # Execution
+    "call_mcp_tool",
+    "get_tool_schema",
+    "list_mcp_tools",
+    "mcp_proxy",
+    # Registry
+    "embed_mcp_tools",
+    "get_mcp_status",
+    "refresh_mcp_tools",
+    # Server
+    "add_mcp_server",
+    "import_mcp_server",
+    "list_mcp_servers",
+    "remove_mcp_server",
+]