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

gobby/mcp_proxy/tools/workflows/__init__.py

@@ -254,13 +254,20 @@ def create_workflows_registry(
         description=(
             "Close the current terminal window/pane (agent self-termination). "
             "Launches ~/.gobby/scripts/agent_shutdown.sh which handles "
-            "terminal-specific shutdown (tmux, iTerm, etc.). Rebuilds script if missing."
+            "terminal-specific shutdown (tmux, iTerm, etc.). Rebuilds script if missing. "
+            "Pass session_id to reliably target the correct terminal PID."
         ),
     )
     async def _close_terminal(
+        session_id: str | None = None,
         signal: str = "TERM",
         delay_ms: int = 0,
     ) -> dict[str, Any]:
-        return await close_terminal(signal, delay_ms)
+        return await close_terminal(
+            session_id=session_id,
+            session_manager=_session_manager,
+            signal=signal,
+            delay_ms=delay_ms,
+        )
 
     return registry

gobby/mcp_proxy/tools/workflows/_lifecycle.py

@@ -13,7 +13,7 @@ from gobby.mcp_proxy.tools.workflows._resolution import (
 from gobby.storage.database import DatabaseProtocol
 from gobby.storage.sessions import LocalSessionManager
 from gobby.utils.project_context import get_workflow_project_path
-from gobby.workflows.definitions import WorkflowState
+from gobby.workflows.definitions import WorkflowDefinition, WorkflowState
 from gobby.workflows.loader import WorkflowLoader
 from gobby.workflows.state_manager import WorkflowStateManager
 
@@ -65,6 +65,13 @@ def activate_workflow(
             "error": f"Workflow '{name}' is lifecycle type (auto-runs on events, not manually activated)",
         }
 
+    # This function only supports step-based workflows (WorkflowDefinition)
+    if not isinstance(definition, WorkflowDefinition):
+        return {
+            "success": False,
+            "error": f"'{name}' is a pipeline. Use pipeline execution tools instead.",
+        }
+
     # Require explicit session_id to prevent cross-session bleed
     if not session_id:
         return {
@@ -280,6 +287,10 @@ def request_step_transition(
     if not definition:
         return {"success": False, "error": f"Workflow '{state.workflow_name}' not found"}
 
+    # Transitions only apply to step-based workflows
+    if not isinstance(definition, WorkflowDefinition):
+        return {"success": False, "error": "Transitions are not supported for pipelines"}
+
     if not any(s.name == to_step for s in definition.steps):
         return {
             "success": False,

gobby/mcp_proxy/tools/workflows/_query.py

@@ -11,6 +11,7 @@ import yaml
 from gobby.mcp_proxy.tools.workflows._resolution import resolve_session_id
 from gobby.storage.sessions import LocalSessionManager
 from gobby.utils.project_context import get_workflow_project_path
+from gobby.workflows.definitions import WorkflowDefinition
 from gobby.workflows.loader import WorkflowLoader
 from gobby.workflows.state_manager import WorkflowStateManager
 
@@ -45,32 +46,50 @@ def get_workflow(
     if not definition:
         return {"success": False, "error": f"Workflow '{name}' not found"}
 
-    return {
-        "success": True,
-        "name": definition.name,
-        "type": definition.type,
-        "description": definition.description,
-        "version": definition.version,
-        "steps": (
-            [
-                {
-                    "name": s.name,
-                    "description": s.description,
-                    "allowed_tools": s.allowed_tools,
-                    "blocked_tools": s.blocked_tools,
-                }
-                for s in definition.steps
-            ]
-            if definition.steps
-            else []
-        ),
-        "triggers": (
-            {name: len(actions) for name, actions in definition.triggers.items()}
-            if definition.triggers
-            else {}
-        ),
-        "settings": definition.settings,
-    }
+    # Handle WorkflowDefinition vs PipelineDefinition
+    if isinstance(definition, WorkflowDefinition):
+        return {
+            "success": True,
+            "name": definition.name,
+            "type": definition.type,
+            "description": definition.description,
+            "version": definition.version,
+            "steps": (
+                [
+                    {
+                        "name": s.name,
+                        "description": s.description,
+                        "allowed_tools": s.allowed_tools,
+                        "blocked_tools": s.blocked_tools,
+                    }
+                    for s in definition.steps
+                ]
+                if definition.steps
+                else []
+            ),
+            "triggers": (
+                {name: len(actions) for name, actions in definition.triggers.items()}
+                if definition.triggers
+                else {}
+            ),
+            "settings": definition.settings,
+        }
+    else:
+        # PipelineDefinition
+        return {
+            "success": True,
+            "name": definition.name,
+            "type": definition.type,
+            "description": definition.description,
+            "version": definition.version,
+            "steps": (
+                [{"id": s.id, "exec": s.exec, "prompt": s.prompt} for s in definition.steps]
+                if definition.steps
+                else []
+            ),
+            "triggers": {},
+            "settings": {},
+        }
 
 
 def list_workflows(

gobby/mcp_proxy/tools/workflows/_terminal.py

@@ -2,20 +2,27 @@
 Terminal tools for workflows.
 """
 
+from __future__ import annotations
+
 import asyncio
 import logging
 import os
 import stat
 import subprocess  # nosec B404
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from gobby.paths import get_install_dir
 
+if TYPE_CHECKING:
+    from gobby.storage.sessions import LocalSessionManager
+
 logger = logging.getLogger(__name__)
 
 
 async def close_terminal(
+    session_id: str | None = None,
+    session_manager: LocalSessionManager | None = None,
     signal: str = "TERM",
     delay_ms: int = 0,
 ) -> dict[str, Any]:
@@ -30,6 +37,10 @@ async def close_terminal(
     (tmux, iTerm, Terminal.app, Ghostty, Kitty, WezTerm, etc.).
 
     Args:
+        session_id: Session ID to look up terminal PID from. Accepts #N, N,
+            UUID, or prefix. If provided with session_manager, the terminal
+            PID is resolved from session.terminal_context.parent_pid.
+        session_manager: LocalSessionManager for session lookups.
         signal: Signal to use for shutdown (TERM, KILL, INT). Default: TERM.
         delay_ms: Optional delay in milliseconds before shutdown. Default: 0.
 
@@ -112,26 +123,51 @@ async def close_terminal(
     if delay_ms > 0:
         await asyncio.sleep(delay_ms / 1000.0)
 
+    # Resolve terminal PID from session context if available
+    target_pid: int | None = None
+    if session_id and session_manager:
+        from gobby.mcp_proxy.tools.workflows._resolution import resolve_session_id
+
+        try:
+            resolved_id = resolve_session_id(session_manager, session_id)
+            if resolved_id:
+                session = session_manager.get(resolved_id)
+                if session and session.terminal_context:
+                    pid_value = session.terminal_context.get("parent_pid")
+                    if pid_value is not None:
+                        target_pid = int(pid_value)
+                        logger.info(f"Resolved terminal PID {target_pid} from session {session_id}")
+        except Exception as e:
+            logger.warning(f"Failed to resolve terminal PID from session: {e}")
+
     # Launch the script
     try:
         # Run in background - we don't wait for it since it kills our process
         env = os.environ.copy()
 
+        # Pass PID as first arg if available, otherwise script will discover via PPID
+        pid_arg = str(target_pid) if target_pid else ""
         subprocess.Popen(  # nosec B603 - script path is from gobby scripts directory
-            [str(script_path), signal.upper(), "0"],  # Delay already applied
+            [str(script_path), pid_arg, signal.upper(), "0"],  # Delay already applied
             env=env,
             start_new_session=True,  # Detach from parent
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
         )
 
-        return {
+        result: dict[str, Any] = {
             "success": True,
             "message": "Shutdown script launched",
             "script_path": str(script_path),
             "script_rebuilt": script_rebuilt,
             "signal": signal.upper(),
         }
+        if target_pid:
+            result["target_pid"] = target_pid
+            result["pid_source"] = "session_terminal_context"
+        else:
+            result["pid_source"] = "ppid_discovery"
+        return result
     except OSError as e:
         return {
             "success": False,

gobby/mcp_proxy/tools/worktrees.py

@@ -169,14 +169,15 @@ def _copy_project_json_to_worktree(
 
 
 def _install_provider_hooks(
-    provider: Literal["claude", "gemini", "codex", "antigravity"] | None,
+    provider: Literal["claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"]
+    | None,
     worktree_path: str | Path,
 ) -> bool:
     """
     Install CLI hooks for the specified provider in the worktree.
 
     Args:
-        provider: Provider name ('claude', 'gemini', 'antigravity', or None)
+        provider: Provider name ('claude', 'gemini', 'antigravity', 'cursor', 'windsurf', 'copilot', or None)
         worktree_path: Path to worktree directory
 
     Returns:
@@ -196,6 +197,16 @@ def _install_provider_hooks(
                 return True
             else:
                 logger.warning(f"Failed to install Claude hooks: {result.get('error')}")
+        elif provider in ("cursor", "windsurf", "copilot"):
+            # These editors use Claude hooks format
+            from gobby.cli.installers.claude import install_claude
+
+            result = install_claude(worktree_path_obj)
+            if result["success"]:
+                logger.info(f"Installed {provider} hooks in worktree: {worktree_path}")
+                return True
+            else:
+                logger.warning(f"Failed to install {provider} hooks: {result.get('error')}")
         elif provider == "gemini":
             from gobby.cli.installers.gemini import install_gemini
 
@@ -326,7 +337,10 @@ def create_worktrees_registry(
         worktree_path: str | None = None,
         create_branch: bool = True,
         project_path: str | None = None,
-        provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
     ) -> dict[str, Any]:
         """
         Create a new git worktree.
@@ -338,7 +352,7 @@ def create_worktrees_registry(
             worktree_path: Optional custom path (defaults to ../{branch_name}).
             create_branch: Whether to create a new branch (default: True).
             project_path: Path to project directory (pass cwd from CLI).
-            provider: CLI provider to install hooks for (claude, gemini, codex, antigravity).
+            provider: CLI provider to install hooks for (claude, gemini, codex, antigravity, cursor, windsurf, copilot).
                      If specified, installs hooks so agents can communicate with daemon.
 
         Returns:
@@ -451,7 +465,7 @@ def create_worktrees_registry(
     async def list_worktrees(
         status: str | None = None,
         agent_session_id: str | None = None,
-        limit: int = 50,
+        limit: int | str = 50,
     ) -> dict[str, Any]:
         """
         List worktrees with optional filters.
@@ -464,6 +478,9 @@ def create_worktrees_registry(
         Returns:
             Dict with list of worktrees.
         """
+        # Handle string inputs from MCP
+        limit = int(limit) if isinstance(limit, str) else limit
+
         # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
         resolved_session_id = agent_session_id
         if agent_session_id:
@@ -569,7 +586,7 @@ def create_worktrees_registry(
     )
     async def delete_worktree(
         worktree_id: str,
-        force: bool = False,
+        force: bool | str = False,
         project_path: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -591,6 +608,9 @@ def create_worktrees_registry(
         Returns:
             Dict with success status.
         """
+        # Handle string inputs from MCP
+        force = force in (True, "true", "True", "1") if isinstance(force, str) else force
+
         worktree = worktree_storage.get(worktree_id)
 
         if not worktree:
@@ -611,8 +631,11 @@ def create_worktrees_registry(
                 # nosec B110 - if context resolution fails, continue without git manager
                 pass
 
-        # Check for uncommitted changes if not forcing
-        if resolved_git_mgr and Path(worktree.worktree_path).exists():
+        # Check if worktree path exists
+        worktree_exists = Path(worktree.worktree_path).exists()
+
+        # Check for uncommitted changes if not forcing (only if path exists)
+        if resolved_git_mgr and worktree_exists:
             status = resolved_git_mgr.get_worktree_status(worktree.worktree_path)
             if status and status.has_uncommitted_changes and not force:
                 return {
@@ -621,8 +644,8 @@ def create_worktrees_registry(
                     "uncommitted_changes": True,
                 }
 
-        # Delete git worktree
-        if resolved_git_mgr:
+        # Delete git worktree (only if path exists - handles orphaned DB records)
+        if resolved_git_mgr and worktree_exists:
             result = resolved_git_mgr.delete_worktree(
                 worktree.worktree_path,
                 force=force,
@@ -634,6 +657,11 @@ def create_worktrees_registry(
                     "success": False,
                     "error": result.error or "Failed to delete git worktree",
                 }
+        elif not worktree_exists:
+            # Worktree path gone (manually deleted) - just clean up DB record
+            logger.info(
+                f"Worktree path {worktree.worktree_path} doesn't exist, cleaning up DB record only"
+            )
 
         # Delete database record
         deleted = worktree_storage.delete(worktree_id)
@@ -744,8 +772,8 @@ def create_worktrees_registry(
     )
     async def detect_stale_worktrees(
         project_path: str | None = None,
-        hours: int = 24,
-        limit: int = 50,
+        hours: int | str = 24,
+        limit: int | str = 50,
     ) -> dict[str, Any]:
         """
         Find stale worktrees (no activity for N hours).
@@ -758,6 +786,10 @@ def create_worktrees_registry(
         Returns:
             Dict with list of stale worktrees.
         """
+        # Handle string inputs from MCP (JSON params come as strings)
+        hours = int(hours) if isinstance(hours, str) else hours
+        limit = int(limit) if isinstance(limit, str) else limit
+
         _, resolved_project_id, error = _resolve_project_context(
             project_path, git_manager, project_id
         )
@@ -794,9 +826,9 @@ def create_worktrees_registry(
     )
     async def cleanup_stale_worktrees(
         project_path: str | None = None,
-        hours: int = 24,
-        dry_run: bool = True,
-        delete_git: bool = False,
+        hours: int | str = 24,
+        dry_run: bool | str = True,
+        delete_git: bool | str = False,
     ) -> dict[str, Any]:
         """
         Cleanup stale worktrees.
@@ -810,6 +842,13 @@ def create_worktrees_registry(
         Returns:
             Dict with cleanup results.
         """
+        # Handle string inputs from MCP (JSON params come as strings)
+        hours = int(hours) if isinstance(hours, str) else hours
+        dry_run = dry_run in (True, "true", "True", "1") if isinstance(dry_run, str) else dry_run
+        delete_git = (
+            delete_git in (True, "true", "True", "1") if isinstance(delete_git, str) else delete_git
+        )
+
         resolved_git_manager, resolved_project_id, error = _resolve_project_context(
             project_path, git_manager, project_id
         )

gobby/memory/context.py

@@ -50,14 +50,14 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 1. Project Context
     if context_memories:
-        parts.append("## Project Context\n")
+        parts.append("## Project Context")
         for mem in context_memories:
-            parts.append(f"{mem.content}\n")
+            parts.append(mem.content)
         parts.append("")
 
     # 2. Preferences
     if pref_memories:
-        parts.append("## Preferences\n")
+        parts.append("## Preferences")
         for mem in pref_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content
@@ -66,7 +66,7 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 3. Patterns
     if pattern_memories:
-        parts.append("## Patterns\n")
+        parts.append("## Patterns")
         for mem in pattern_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content
@@ -75,7 +75,7 @@ def build_memory_context(memories: list[Memory]) -> str:
 
     # 4. Facts/Other
     if fact_memories:
-        parts.append("## Facts\n")
+        parts.append("## Facts")
         for mem in fact_memories:
             content = _strip_leading_bullet(mem.content)
             if content:  # Skip empty content

gobby/runner.py

@@ -1,10 +1,12 @@
+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
 
@@ -37,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__)
 
 
@@ -182,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)
@@ -234,6 +272,9 @@ class GobbyRunner:
             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(
@@ -252,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,
@@ -260,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
@@ -273,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()
@@ -287,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)."""
@@ -309,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(
@@ -324,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)."""
@@ -433,11 +536,10 @@ 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,