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

gobby/mcp_proxy/stdio.py

@@ -116,6 +116,16 @@ class DaemonProxy:
             "validate_task",
         ):
             timeout = 300.0
+        # Wait tools: use the requested timeout plus a buffer
+        elif tool_name in (
+            "wait_for_task",
+            "wait_for_any_task",
+            "wait_for_all_tasks",
+        ):
+            # Extract timeout from arguments, default to 300s if not specified
+            arg_timeout = float((arguments or {}).get("timeout", 300.0))
+            # Add 30s buffer for HTTP overhead
+            timeout = arg_timeout + 30.0
 
         return await self._request(
             "POST",
@@ -242,13 +252,15 @@ class DaemonProxy:
             },
         )
 
-    async def init_project(
-        self, name: str | None = None, github_url: str | None = None
-    ) -> dict[str, Any]:
-        """Initialize a project - use 'gobby init' CLI command instead."""
+    async def init_project(self, name: str, project_path: str | None = None) -> dict[str, Any]:
+        """Initialize a new Gobby project.
+
+        Note: Project initialization requires CLI access and cannot be done
+        via the MCP proxy. Use 'gobby init' command instead.
+        """
         return {
             "success": False,
-            "error": "init_project requires CLI access. Run 'gobby init' from your terminal.",
+            "error": "Project initialization requires CLI access. Use 'gobby init' command instead.",
         }
 
 
@@ -410,22 +422,6 @@ def register_proxy_tools(mcp: FastMCP, proxy: DaemonProxy) -> None:
             cwd=cwd,
         )
 
-    @mcp.tool()
-    async def init_project(
-        name: str | None = None, github_url: str | None = None
-    ) -> dict[str, Any]:
-        """
-        Initialize a new Gobby project in the current directory.
-
-        Args:
-            name: Optional project name (auto-detected from directory name if not provided)
-            github_url: Optional GitHub URL (auto-detected from git remote if not provided)
-
-        Returns:
-            Dict with success status and project details
-        """
-        return await proxy.init_project(name, github_url)
-
     @mcp.tool()
     async def add_mcp_server(
         name: str,
@@ -503,6 +499,26 @@ def register_proxy_tools(mcp: FastMCP, proxy: DaemonProxy) -> None:
             query=query,
         )
 
+    @mcp.tool()
+    async def init_project(
+        name: str,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Initialize a new Gobby project.
+
+        Note: Project initialization requires CLI access and cannot be done
+        via the MCP proxy. Use 'gobby init' command instead.
+
+        Args:
+            name: Project name
+            project_path: Path to project directory (optional)
+
+        Returns:
+            Result dict with error (CLI access required)
+        """
+        return await proxy.init_project(name, project_path)
+
 
 async def ensure_daemon_running() -> None:
     """Ensure the Gobby daemon is running and healthy."""

gobby/mcp_proxy/tools/agents.py

@@ -40,6 +40,9 @@ def create_agents_registry(
     git_manager: Any | None = None,
     clone_storage: Any | None = None,
     clone_manager: Any | None = None,
+    # For mode=self (workflow activation on caller session)
+    workflow_loader: Any | None = None,
+    db: Any | None = None,
 ) -> InternalToolRegistry:
     """
     Create an agent tool registry with all agent-related tools.
@@ -430,6 +433,10 @@ def create_agents_registry(
         clone_storage=clone_storage,
         clone_manager=clone_manager,
         session_manager=session_manager,
+        workflow_loader=workflow_loader,
+        # For mode=self (workflow activation on caller session)
+        state_manager=workflow_state_manager,
+        db=db,
     )
 
     # Merge spawn_agent tools into agents registry

gobby/mcp_proxy/tools/artifacts.py

@@ -19,11 +19,11 @@ from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 
 if TYPE_CHECKING:
     from gobby.storage.artifacts import LocalArtifactManager
-    from gobby.storage.database import LocalDatabase
+    from gobby.storage.database import DatabaseProtocol
 
 
 def create_artifacts_registry(
-    db: LocalDatabase | None = None,
+    db: DatabaseProtocol | None = None,
     artifact_manager: LocalArtifactManager | None = None,
     session_manager: Any | None = None,
 ) -> InternalToolRegistry:
@@ -31,7 +31,7 @@ def create_artifacts_registry(
     Create an artifacts tool registry with all artifact-related tools.
 
     Args:
-        db: LocalDatabase instance (used to create artifact_manager if not provided)
+        db: DatabaseProtocol instance (used to create artifact_manager if not provided)
         artifact_manager: LocalArtifactManager instance
         session_manager: Session manager for resolving session references
 

gobby/mcp_proxy/tools/hub.py

@@ -45,7 +45,7 @@ def create_hub_registry(
     """
     registry = HubToolRegistry(
         name="gobby-hub",
-        description="Hub (cross-project) queries - list_all_projects, list_cross_project_tasks, list_cross_project_sessions, hub_stats",
+        description="Hub (cross-project) queries and system info - get_machine_id, list_all_projects, list_cross_project_tasks, list_cross_project_sessions, hub_stats",
     )
 
     def _get_hub_db() -> LocalDatabase | None:
@@ -54,6 +54,35 @@ def create_hub_registry(
             return None
         return LocalDatabase(hub_db_path)
 
+    @registry.tool(
+        name="get_machine_id",
+        description="Get the daemon's machine identifier. Use this from sandboxed agents that cannot read ~/.gobby/machine_id directly.",
+    )
+    async def get_machine_id() -> dict[str, Any]:
+        """
+        Get the machine identifier used by this Gobby daemon.
+
+        The machine_id is stored in ~/.gobby/machine_id and is generated
+        once on first daemon run. This tool provides read-only access to
+        the daemon's authoritative machine_id.
+
+        Returns:
+            Dict with machine_id or error if not found.
+        """
+        from gobby.utils.machine_id import get_machine_id as _get_machine_id
+
+        machine_id = _get_machine_id()
+        if machine_id:
+            return {
+                "success": True,
+                "machine_id": machine_id,
+            }
+
+        return {
+            "success": False,
+            "error": "machine_id not found - daemon may not have initialized properly",
+        }
+
     @registry.tool(
         name="list_all_projects",
         description="List all unique projects in the hub database.",

gobby/mcp_proxy/tools/orchestration/cleanup.py

@@ -38,7 +38,7 @@ def register_cleanup(
         """
         Approve a reviewed task and clean up its worktree.
 
-        This tool transitions a task from "review" to "closed" status
+        This tool transitions a task from "needs_review" to "closed" status
         and optionally deletes the associated worktree.
 
         Args:
@@ -71,11 +71,11 @@ def register_cleanup(
                 "error": f"Task not found: {task_id}",
             }
 
-        # Verify task is in review status
-        if task.status != "review":
+        # Verify task is in needs_review status
+        if task.status != "needs_review":
             return {
                 "success": False,
-                "error": f"Task must be in 'review' status to approve. Current status: {task.status}",
+                "error": f"Task must be in 'needs_review' status to approve. Current status: {task.status}",
             }
 
         # Get associated worktree (if any)
@@ -148,7 +148,7 @@ def register_cleanup(
         name="approve_and_cleanup",
         description=(
             "Approve a reviewed task and clean up its worktree. "
-            "Transitions task from 'review' to 'closed' status and deletes worktree."
+            "Transitions task from 'needs_review' to 'closed' status and deletes worktree."
         ),
         input_schema={
             "type": "object",

gobby/mcp_proxy/tools/orchestration/monitor.py

@@ -101,7 +101,7 @@ def register_monitor(
                 closed_tasks.append(task_info)
             elif task.status == "in_progress":
                 in_progress_tasks.append(task_info)
-            elif task.status == "review":
+            elif task.status == "needs_review":
                 review_tasks.append(task_info)
             else:
                 open_tasks.append(task_info)

gobby/mcp_proxy/tools/orchestration/orchestrate.py

@@ -35,7 +35,9 @@ def register_orchestrator(
 
     async def orchestrate_ready_tasks(
         parent_task_id: str,
-        provider: Literal["claude", "gemini", "codex", "antigravity"] = "gemini",
+        provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ] = "gemini",
         model: str | None = None,
         terminal: str = "auto",
         mode: str = "terminal",
@@ -43,7 +45,10 @@ def register_orchestrator(
         max_concurrent: int = 3,
         parent_session_id: str | None = None,
         project_path: str | None = None,
-        coding_provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        coding_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
         coding_model: str | None = None,
         base_branch: str | None = None,
     ) -> dict[str, Any]:
@@ -652,7 +657,7 @@ def register_orchestrator(
                 },
                 "provider": {
                     "type": "string",
-                    "description": "Fallback LLM provider (claude, gemini, codex, antigravity)",
+                    "description": "Fallback LLM provider (claude, gemini, codex, antigravity, cursor, windsurf, copilot)",
                     "default": "gemini",
                 },
                 "model": {

gobby/mcp_proxy/tools/orchestration/review.py

@@ -30,7 +30,9 @@ def register_reviewer(
 
     async def spawn_review_agent(
         task_id: str,
-        review_provider: Literal["claude", "gemini", "codex", "antigravity"] = "claude",
+        review_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ] = "claude",
         review_model: str | None = "claude-opus-4-5",
         terminal: str = "auto",
         mode: str = "terminal",
@@ -61,7 +63,15 @@ def register_reviewer(
         """
         # Validate mode and review_provider
         allowed_modes = {"terminal", "embedded", "headless"}
-        allowed_providers = {"claude", "gemini", "codex", "antigravity"}
+        allowed_providers = {
+            "claude",
+            "gemini",
+            "codex",
+            "antigravity",
+            "cursor",
+            "windsurf",
+            "copilot",
+        }
 
         mode_lower = mode.lower() if mode else "terminal"
         if mode_lower not in allowed_modes:
@@ -314,7 +324,7 @@ def register_reviewer(
                 },
                 "review_provider": {
                     "type": "string",
-                    "description": "LLM provider for review (claude, gemini, codex, antigravity)",
+                    "description": "LLM provider for review (claude, gemini, codex, antigravity, cursor, windsurf, copilot)",
                     "default": "claude",
                 },
                 "review_model": {
@@ -350,7 +360,10 @@ def register_reviewer(
     async def process_completed_agents(
         parent_session_id: str,
         spawn_reviews: bool = True,
-        review_provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        review_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
         review_model: str | None = None,
         terminal: str = "auto",
         mode: str = "terminal",

gobby/mcp_proxy/tools/orchestration/wait.py

@@ -62,7 +62,7 @@ def register_wait(
 
         # Consider task complete if status is "closed" or "review"
         # (review tasks have completed their work, just awaiting human approval)
-        is_complete = task.status in ("closed", "review")
+        is_complete = task.status in ("closed", "needs_review")
         return is_complete, task_info
 
     async def wait_for_task(
@@ -73,7 +73,7 @@ def register_wait(
         """
         Wait for a single task to complete.
 
-        Blocks until the task reaches "closed" or "review" status, or timeout expires.
+        Blocks until the task reaches "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_id: Task reference (#N, N, path, or UUID)
@@ -170,7 +170,7 @@ def register_wait(
         name="wait_for_task",
         description=(
             "Wait for a single task to complete. "
-            "Blocks until task reaches 'closed' or 'review' status, or timeout expires."
+            "Blocks until task reaches 'closed' or 'needs_review' status, or timeout expires."
         ),
         input_schema={
             "type": "object",
@@ -201,7 +201,7 @@ def register_wait(
         """
         Wait for any one of multiple tasks to complete.
 
-        Blocks until at least one task reaches "closed" or "review" status, or timeout expires.
+        Blocks until at least one task reaches "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_ids: List of task references (#N, N, path, or UUID)
@@ -290,7 +290,7 @@ def register_wait(
         name="wait_for_any_task",
         description=(
             "Wait for any one of multiple tasks to complete. "
-            "Returns as soon as the first task reaches 'closed' or 'review' status."
+            "Returns as soon as the first task reaches 'closed' or 'needs_review' status."
         ),
         input_schema={
             "type": "object",
@@ -322,7 +322,7 @@ def register_wait(
         """
         Wait for all tasks to complete.
 
-        Blocks until all tasks reach "closed" or "review" status, or timeout expires.
+        Blocks until all tasks reach "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_ids: List of task references (#N, N, path, or UUID)
@@ -442,7 +442,7 @@ def register_wait(
         name="wait_for_all_tasks",
         description=(
             "Wait for all tasks to complete. "
-            "Blocks until all tasks reach 'closed' or 'review' status, or timeout expires."
+            "Blocks until all tasks reach 'closed' or 'needs_review' status, or timeout expires."
         ),
         input_schema={
             "type": "object",

gobby/mcp_proxy/tools/pipelines/__init__.py

@@ -0,0 +1,254 @@
+"""
+Internal MCP tools for Gobby Pipeline System.
+
+Exposes functionality for:
+- list_pipelines: Discover available pipeline definitions
+- Dynamic pipeline tools: Pipelines with expose_as_tool=True are exposed as MCP tools
+
+These tools are registered with the InternalToolRegistry and accessed
+via the downstream proxy pattern (call_tool, list_tools, get_tool_schema).
+"""
+
+import logging
+from typing import Any
+
+from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.mcp_proxy.tools.pipelines._discovery import list_pipelines
+from gobby.mcp_proxy.tools.pipelines._execution import (
+    approve_pipeline,
+    get_pipeline_status,
+    reject_pipeline,
+    run_pipeline,
+)
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "create_pipelines_registry",
+]
+
+
+def create_pipelines_registry(
+    loader: Any | None = None,
+    executor: Any | None = None,
+    execution_manager: Any | None = None,
+) -> InternalToolRegistry:
+    """
+    Create a pipeline tool registry with all pipeline-related tools.
+
+    Args:
+        loader: WorkflowLoader instance for discovering pipelines
+        executor: PipelineExecutor instance for running pipelines
+        execution_manager: LocalPipelineExecutionManager for tracking executions
+
+    Returns:
+        InternalToolRegistry with pipeline tools registered
+    """
+    _loader = loader
+    _executor = executor
+    _execution_manager = execution_manager
+
+    registry = InternalToolRegistry(
+        name="gobby-pipelines",
+        description="Pipeline management - list, run, and monitor pipeline executions",
+    )
+
+    # Register dynamic tools for pipelines with expose_as_tool=True
+    _register_exposed_pipeline_tools(registry, _loader, _executor)
+
+    @registry.tool(
+        name="list_pipelines",
+        description="List available pipeline definitions from project and global directories.",
+    )
+    def _list_pipelines(
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        return list_pipelines(_loader, project_path)
+
+    @registry.tool(
+        name="run_pipeline",
+        description="Run a pipeline by name with given inputs.",
+    )
+    async def _run_pipeline(
+        name: str,
+        inputs: dict[str, Any] | None = None,
+        project_id: str | None = None,
+    ) -> dict[str, Any]:
+        return await run_pipeline(
+            loader=_loader,
+            executor=_executor,
+            name=name,
+            inputs=inputs or {},
+            project_id=project_id or "",
+        )
+
+    @registry.tool(
+        name="approve_pipeline",
+        description="Approve a pipeline execution that is waiting for approval.",
+    )
+    async def _approve_pipeline(
+        token: str,
+        approved_by: str | None = None,
+    ) -> dict[str, Any]:
+        return await approve_pipeline(
+            executor=_executor,
+            token=token,
+            approved_by=approved_by,
+        )
+
+    @registry.tool(
+        name="reject_pipeline",
+        description="Reject a pipeline execution that is waiting for approval.",
+    )
+    async def _reject_pipeline(
+        token: str,
+        rejected_by: str | None = None,
+    ) -> dict[str, Any]:
+        return await reject_pipeline(
+            executor=_executor,
+            token=token,
+            rejected_by=rejected_by,
+        )
+
+    @registry.tool(
+        name="get_pipeline_status",
+        description="Get the status of a pipeline execution including step details.",
+    )
+    def _get_pipeline_status(
+        execution_id: str,
+    ) -> dict[str, Any]:
+        return get_pipeline_status(
+            execution_manager=_execution_manager,
+            execution_id=execution_id,
+        )
+
+    return registry
+
+
+def _register_exposed_pipeline_tools(
+    registry: InternalToolRegistry,
+    loader: Any | None,
+    executor: Any | None,
+) -> None:
+    """
+    Register dynamic tools for pipelines with expose_as_tool=True.
+
+    Each exposed pipeline becomes an MCP tool named "pipeline:<pipeline_name>".
+
+    Args:
+        registry: The registry to add tools to
+        loader: WorkflowLoader for discovering pipelines
+        executor: PipelineExecutor for running pipelines
+    """
+    if loader is None:
+        logger.debug("Skipping dynamic pipeline tools: no loader")
+        return
+
+    try:
+        discovered = loader.discover_pipeline_workflows()
+    except Exception:
+        logger.warning("Failed to discover pipelines for dynamic tools", exc_info=True)
+        return
+
+    for workflow in discovered:
+        pipeline = workflow.definition
+
+        # Only expose pipelines with expose_as_tool=True
+        if not getattr(pipeline, "expose_as_tool", False):
+            continue
+
+        _create_pipeline_tool(registry, pipeline, loader, executor)
+
+
+def _create_pipeline_tool(
+    registry: InternalToolRegistry,
+    pipeline: Any,
+    loader: Any,
+    executor: Any | None,
+) -> None:
+    """
+    Create a dynamic tool for a single pipeline.
+
+    Args:
+        registry: The registry to add the tool to
+        pipeline: The PipelineDefinition to expose
+        loader: WorkflowLoader for loading pipelines
+        executor: PipelineExecutor for running pipelines
+    """
+    tool_name = f"pipeline:{pipeline.name}"
+    description = pipeline.description or f"Run the {pipeline.name} pipeline"
+
+    # Build input schema from pipeline inputs
+    input_schema = _build_input_schema(pipeline)
+
+    # Create closure to capture pipeline name
+    pipeline_name = pipeline.name
+
+    async def _execute_pipeline(**kwargs: Any) -> dict[str, Any]:
+        return await run_pipeline(
+            loader=loader,
+            executor=executor,
+            name=pipeline_name,
+            inputs=kwargs,
+            project_id="",
+        )
+
+    # Register the tool with the schema
+    registry.register(
+        name=tool_name,
+        description=description,
+        func=_execute_pipeline,
+        input_schema=input_schema,
+    )
+
+    logger.debug(f"Registered dynamic pipeline tool: {tool_name}")
+
+
+def _build_input_schema(pipeline: Any) -> dict[str, Any]:
+    """
+    Build JSON Schema for pipeline inputs.
+
+    Args:
+        pipeline: The PipelineDefinition
+
+    Returns:
+        JSON Schema dict for the pipeline's inputs
+    """
+    properties = {}
+    required = []
+
+    for name, input_def in pipeline.inputs.items():
+        if isinstance(input_def, dict):
+            # Input is already a schema-like dict
+            prop = {}
+            if "type" in input_def:
+                prop["type"] = input_def["type"]
+            else:
+                prop["type"] = "string"
+
+            if "description" in input_def:
+                prop["description"] = input_def["description"]
+
+            if "default" in input_def:
+                prop["default"] = input_def["default"]
+            else:
+                # No default means required
+                required.append(name)
+
+            properties[name] = prop
+        else:
+            # Input is a simple default value
+            properties[name] = {
+                "type": "string",
+                "default": input_def,
+            }
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+    }
+
+    if required:
+        schema["required"] = required
+
+    return schema

gobby/mcp_proxy/tools/pipelines/_discovery.py

@@ -0,0 +1,67 @@
+"""Pipeline discovery tools."""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def list_pipelines(
+    loader: Any,
+    project_path: str | None = None,
+) -> dict[str, Any]:
+    """
+    List available pipeline definitions.
+
+    Args:
+        loader: WorkflowLoader instance
+        project_path: Optional project path for project-specific pipelines
+
+    Returns:
+        Dict with success status and list of pipeline info
+    """
+    if not loader:
+        return {
+            "success": False,
+            "error": "No loader configured",
+            "pipelines": [],
+        }
+
+    try:
+        discovered = loader.discover_pipeline_workflows(project_path=project_path)
+
+        pipelines = []
+        for workflow in discovered:
+            pipeline_info = {
+                "name": workflow.name,
+                "description": workflow.definition.description,
+                "is_project": workflow.is_project,
+                "path": str(workflow.path),
+                "priority": workflow.priority,
+            }
+
+            # Add step count if available
+            if hasattr(workflow.definition, "steps"):
+                pipeline_info["step_count"] = len(workflow.definition.steps)
+
+            pipelines.append(pipeline_info)
+
+        return {
+            "success": True,
+            "pipelines": pipelines,
+            "count": len(pipelines),
+        }
+
+    except (FileNotFoundError, ValueError) as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "pipelines": [],
+        }
+    except Exception:
+        logger.exception("Unexpected error discovering pipelines")
+        return {
+            "success": False,
+            "error": "Internal error during pipeline discovery",
+            "pipelines": [],
+        }