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

gobby/runner.py

@@ -1,14 +1,17 @@
+from __future__ import annotations
+
 import asyncio
 import logging
 import os
 import signal
 import sys
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import uvicorn
 
 from gobby.agents.runner import AgentRunner
+from gobby.app_context import ServiceContainer
 from gobby.config.app import load_config
 from gobby.llm import LLMService, create_llm_service
 from gobby.llm.resolver import ExecutorRegistry
@@ -36,6 +39,12 @@ from gobby.worktrees.git import WorktreeGitManager
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
+# Type hints for pipeline components (imported lazily at runtime)
+if TYPE_CHECKING:
+    from gobby.storage.pipelines import LocalPipelineExecutionManager
+    from gobby.workflows.loader import WorkflowLoader
+    from gobby.workflows.pipeline_executor import PipelineExecutor
+
 logger = logging.getLogger(__name__)
 
 
@@ -181,6 +190,36 @@ class GobbyRunner:
         except Exception as e:
             logger.debug(f"Could not initialize git manager: {e}")
 
+        # Initialize Pipeline Components
+        self.workflow_loader: WorkflowLoader | None = None
+        self.pipeline_execution_manager: LocalPipelineExecutionManager | None = None
+        self.pipeline_executor: PipelineExecutor | None = None
+        try:
+            from gobby.storage.pipelines import LocalPipelineExecutionManager
+            from gobby.workflows.loader import WorkflowLoader
+            from gobby.workflows.pipeline_executor import PipelineExecutor
+
+            self.workflow_loader = WorkflowLoader()
+            if self.project_id:
+                self.pipeline_execution_manager = LocalPipelineExecutionManager(
+                    db=self.database,
+                    project_id=self.project_id,
+                )
+                if self.llm_service:
+                    self.pipeline_executor = PipelineExecutor(
+                        db=self.database,
+                        execution_manager=self.pipeline_execution_manager,
+                        llm_service=self.llm_service,
+                        loader=self.workflow_loader,
+                    )
+                    logger.debug("Pipeline executor initialized")
+                else:
+                    logger.debug("Pipeline executor not initialized: LLM service not available")
+            else:
+                logger.debug("Pipeline execution manager not initialized: no project context")
+        except Exception as e:
+            logger.warning(f"Failed to initialize pipeline components: {e}")
+
         # Initialize Agent Runner (Phase 7 - Subagents)
         # Create executor registry for lazy executor creation
         self.executor_registry = ExecutorRegistry(config=self.config)
@@ -212,29 +251,41 @@ class GobbyRunner:
         )
 
         # HTTP Server
-        self.http_server = HTTPServer(
-            port=self.config.daemon_port,
-            test_mode=self.config.test_mode,
-            mcp_manager=self.mcp_proxy,
-            mcp_db_manager=self.mcp_db_manager,
+        # Bundle services into container
+        services = ServiceContainer(
             config=self.config,
+            database=self.database,
             session_manager=self.session_manager,
             task_manager=self.task_manager,
             task_sync_manager=self.task_sync_manager,
-            message_manager=self.message_manager,
+            memory_sync_manager=self.memory_sync_manager,
             memory_manager=self.memory_manager,
             llm_service=self.llm_service,
-            message_processor=self.message_processor,
-            memory_sync_manager=self.memory_sync_manager,
-            task_validator=self.task_validator,
+            mcp_manager=self.mcp_proxy,
+            mcp_db_manager=self.mcp_db_manager,
             metrics_manager=self.metrics_manager,
             agent_runner=self.agent_runner,
+            message_processor=self.message_processor,
+            message_manager=self.message_manager,
+            task_validator=self.task_validator,
             worktree_storage=self.worktree_storage,
             clone_storage=self.clone_storage,
             git_manager=self.git_manager,
             project_id=self.project_id,
+            pipeline_executor=self.pipeline_executor,
+            workflow_loader=self.workflow_loader,
+            pipeline_execution_manager=self.pipeline_execution_manager,
         )
 
+        self.http_server = HTTPServer(
+            services=services,
+            port=self.config.daemon_port,
+            test_mode=self.config.test_mode,
+        )
+
+        # Inject server into container for circular ref if needed later
+        # self.http_server.services = services
+
         # Ensure message_processor property is set (redundant but explicit):
         self.http_server.message_processor = self.message_processor
 
@@ -242,7 +293,7 @@ class GobbyRunner:
         self.websocket_server: WebSocketServer | None = None
         if self.config.websocket and getattr(self.config.websocket, "enabled", True):
             websocket_config = WebSocketConfig(
-                host="localhost",
+                host=self.config.bind_host,
                 port=self.config.websocket.port,
                 ping_interval=self.config.websocket.ping_interval,
                 ping_timeout=self.config.websocket.ping_timeout,
@@ -250,6 +301,7 @@ class GobbyRunner:
             self.websocket_server = WebSocketServer(
                 config=websocket_config,
                 mcp_manager=self.mcp_proxy,
+                llm_service=self.llm_service,
             )
             # Pass WebSocket server reference to HTTP server for broadcasting
             self.http_server.websocket_server = self.websocket_server
@@ -263,6 +315,9 @@ class GobbyRunner:
             # Register agent event callback for WebSocket broadcasting
             self._setup_agent_event_broadcasting()
 
+            # Register pipeline event callback for WebSocket broadcasting
+            self._setup_pipeline_event_broadcasting()
+
     def _init_database(self) -> DatabaseProtocol:
         """Initialize hub database."""
         hub_db_path = Path(self.config.database_path).expanduser()
@@ -277,13 +332,23 @@ class GobbyRunner:
         return hub_db
 
     def _setup_agent_event_broadcasting(self) -> None:
-        """Set up WebSocket broadcasting for agent lifecycle events."""
+        """Set up WebSocket broadcasting for agent lifecycle events and PTY reading."""
+        from gobby.agents.pty_reader import get_pty_reader_manager
         from gobby.agents.registry import get_running_agent_registry
 
         if not self.websocket_server:
             return
 
         registry = get_running_agent_registry()
+        pty_manager = get_pty_reader_manager()
+
+        # Set up PTY output callback to broadcast via WebSocket
+        async def broadcast_terminal_output(run_id: str, data: str) -> None:
+            """Broadcast terminal output via WebSocket."""
+            if self.websocket_server:
+                await self.websocket_server.broadcast_terminal_output(run_id, data)
+
+        pty_manager.set_output_callback(broadcast_terminal_output)
 
         def broadcast_agent_event(event_type: str, run_id: str, data: dict[str, Any]) -> None:
             """Broadcast agent events via WebSocket (non-blocking)."""
@@ -299,6 +364,32 @@ class GobbyRunner:
                 except Exception as e:
                     logger.warning(f"Failed to broadcast agent event {event_type}: {e}")
 
+            # Handle PTY reader start/stop for embedded agents
+            if event_type == "agent_started" and data.get("mode") == "embedded":
+                # Start PTY reader for embedded agents
+                agent = registry.get(run_id)
+                if agent and agent.master_fd is not None:
+
+                    async def start_pty_reader() -> None:
+                        await pty_manager.start_reader(agent)
+
+                    task = asyncio.create_task(start_pty_reader())
+                    task.add_done_callback(_log_broadcast_exception)
+
+            elif event_type in (
+                "agent_completed",
+                "agent_failed",
+                "agent_cancelled",
+                "agent_timeout",
+            ):
+                # Stop PTY reader when agent finishes
+
+                async def stop_pty_reader() -> None:
+                    await pty_manager.stop_reader(run_id)
+
+                task = asyncio.create_task(stop_pty_reader())
+                task.add_done_callback(_log_broadcast_exception)
+
             # Create async task to broadcast and attach exception callback
             task = asyncio.create_task(
                 self.websocket_server.broadcast_agent_event(
@@ -314,7 +405,29 @@ class GobbyRunner:
             task.add_done_callback(_log_broadcast_exception)
 
         registry.add_event_callback(broadcast_agent_event)
-        logger.debug("Agent event broadcasting enabled")
+        logger.debug("Agent event broadcasting and PTY reading enabled")
+
+    def _setup_pipeline_event_broadcasting(self) -> None:
+        """Set up WebSocket broadcasting for pipeline execution events."""
+        if not self.websocket_server:
+            return
+
+        if not self.pipeline_executor:
+            logger.debug("Pipeline event broadcasting skipped: no pipeline executor")
+            return
+
+        async def broadcast_pipeline_event(event: str, execution_id: str, **kwargs: Any) -> None:
+            """Broadcast pipeline events via WebSocket."""
+            if self.websocket_server:
+                await self.websocket_server.broadcast_pipeline_event(
+                    event=event,
+                    execution_id=execution_id,
+                    **kwargs,
+                )
+
+        # Set the callback on the pipeline executor
+        self.pipeline_executor.event_callback = broadcast_pipeline_event
+        logger.debug("Pipeline event broadcasting enabled")
 
     async def _metrics_cleanup_loop(self) -> None:
         """Background loop for periodic metrics cleanup (every 24 hours)."""
@@ -423,13 +536,14 @@ class GobbyRunner:
                 websocket_task = asyncio.create_task(self.websocket_server.start())
 
             # Start HTTP server
-            # nosec B104: 0.0.0.0 binding is intentional - daemon serves local network
+            graceful_shutdown_timeout = 15
             config = uvicorn.Config(
                 self.http_server.app,
-                host="0.0.0.0",  # nosec B104 - local daemon needs network access
+                host=self.config.bind_host,
                 port=self.http_server.port,
                 log_level="warning",
                 access_log=False,
+                timeout_graceful_shutdown=graceful_shutdown_timeout,
             )
             server = uvicorn.Server(config)
             server_task = asyncio.create_task(server.serve())
@@ -439,9 +553,10 @@ class GobbyRunner:
                 await asyncio.sleep(0.5)
 
             # Cleanup with timeouts to prevent hanging
+            # Use timeout slightly longer than uvicorn's graceful shutdown to let it finish
             server.should_exit = True
             try:
-                await asyncio.wait_for(server_task, timeout=3.0)
+                await asyncio.wait_for(server_task, timeout=graceful_shutdown_timeout + 5)
             except TimeoutError:
                 logger.warning("HTTP server shutdown timed out")