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

gobby/agents/pty_reader.py

@@ -0,0 +1,192 @@
+"""
+PTY Reader for streaming terminal output from embedded agents.
+
+Reads from PTY master file descriptors and broadcasts output via callbacks.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import select
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from gobby.agents.registry import RunningAgent
+
+logger = logging.getLogger(__name__)
+
+# Type for output callback: async function(run_id, data)
+OutputCallback = Callable[[str, str], Awaitable[None]]
+
+
+class PTYReaderManager:
+    """
+    Manages PTY reading tasks for embedded agents.
+
+    Starts a reader task for each agent with a master_fd and
+    broadcasts output via the provided callback.
+    """
+
+    def __init__(self, output_callback: OutputCallback | None = None):
+        """
+        Initialize the PTY reader manager.
+
+        Args:
+            output_callback: Async callback for terminal output (run_id, data)
+        """
+        self._output_callback = output_callback
+        self._reader_tasks: dict[str, asyncio.Task[None]] = {}
+        self._stop_events: dict[str, asyncio.Event] = {}
+        self._lock = asyncio.Lock()
+
+    def set_output_callback(self, callback: OutputCallback) -> None:
+        """Set the output callback for terminal data."""
+        self._output_callback = callback
+
+    async def start_reader(self, agent: RunningAgent) -> bool:
+        """
+        Start a PTY reader for an agent.
+
+        Args:
+            agent: RunningAgent with master_fd set
+
+        Returns:
+            True if reader was started, False if already running or no fd
+        """
+        if agent.master_fd is None:
+            return False
+
+        async with self._lock:
+            if agent.run_id in self._reader_tasks:
+                return False  # Already reading
+
+            stop_event = asyncio.Event()
+            self._stop_events[agent.run_id] = stop_event
+
+            task = asyncio.create_task(
+                self._read_loop(agent.run_id, agent.master_fd, stop_event),
+                name=f"pty_reader_{agent.run_id}",
+            )
+            self._reader_tasks[agent.run_id] = task
+
+            logger.debug(f"Started PTY reader for agent {agent.run_id}")
+            return True
+
+    async def stop_reader(self, run_id: str) -> bool:
+        """
+        Stop a PTY reader for an agent.
+
+        Args:
+            run_id: Agent run ID
+
+        Returns:
+            True if reader was stopped, False if not running
+        """
+        async with self._lock:
+            stop_event = self._stop_events.pop(run_id, None)
+            task = self._reader_tasks.pop(run_id, None)
+
+        if stop_event:
+            stop_event.set()
+
+        if task:
+            task.cancel()
+            try:
+                await asyncio.wait_for(task, timeout=1.0)
+            except (asyncio.CancelledError, TimeoutError):
+                pass
+            logger.debug(f"Stopped PTY reader for agent {run_id}")
+            return True
+
+        return False
+
+    async def stop_all(self) -> None:
+        """Stop all PTY readers."""
+        async with self._lock:
+            run_ids = list(self._reader_tasks.keys())
+
+        for run_id in run_ids:
+            await self.stop_reader(run_id)
+
+    async def _read_loop(
+        self,
+        run_id: str,
+        master_fd: int,
+        stop_event: asyncio.Event,
+    ) -> None:
+        """
+        Read loop for a single PTY.
+
+        Reads from the master_fd and broadcasts via callback.
+        Uses select to avoid blocking the event loop.
+
+        Args:
+            run_id: Agent run ID
+            master_fd: PTY master file descriptor
+            stop_event: Event to signal stop
+        """
+        loop = asyncio.get_running_loop()
+
+        try:
+            while not stop_event.is_set():
+                # Use select with timeout to check for data
+                try:
+                    ready, _, _ = await loop.run_in_executor(
+                        None,
+                        lambda: select.select([master_fd], [], [], 0.1),
+                    )
+                except (ValueError, OSError):
+                    # FD closed or invalid
+                    break
+
+                if not ready:
+                    continue
+
+                # Read available data
+                try:
+                    data = await loop.run_in_executor(
+                        None,
+                        lambda: os.read(master_fd, 4096),
+                    )
+                except OSError as e:
+                    # FD closed or error
+                    logger.debug(f"PTY read error for {run_id}: {e}")
+                    break
+
+                if not data:
+                    # EOF
+                    break
+
+                # Decode and broadcast
+                try:
+                    text = data.decode("utf-8", errors="replace")
+                except Exception:
+                    text = data.decode("latin-1")
+
+                if self._output_callback:
+                    try:
+                        await self._output_callback(run_id, text)
+                    except Exception as e:
+                        logger.warning(f"Output callback error for {run_id}: {e}")
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"PTY reader error for {run_id}: {e}")
+        finally:
+            logger.debug(f"PTY reader finished for {run_id}")
+
+
+# Global singleton
+_pty_reader_manager: PTYReaderManager | None = None
+
+
+def get_pty_reader_manager() -> PTYReaderManager:
+    """Get the global PTY reader manager singleton."""
+    global _pty_reader_manager
+    if _pty_reader_manager is None:
+        _pty_reader_manager = PTYReaderManager()
+    return _pty_reader_manager

gobby/agents/registry.py

@@ -338,9 +338,18 @@ class RunningAgentRegistry:
                                             cmdline = ps_result.stdout.strip()
                                             # Verify it's actually the agent process
                                             # (contains session-id and matches expected CLI)
+                                            # Check both provider name and "claude" (for cursor/windsurf/copilot)
+                                            is_matched = agent.provider in cmdline.lower()
+                                            if not is_matched and agent.provider in (
+                                                "cursor",
+                                                "windsurf",
+                                                "copilot",
+                                            ):
+                                                is_matched = "claude" in cmdline.lower()
+
                                             if (
                                                 f"session-id {agent.session_id}" in cmdline
-                                                and agent.provider in cmdline.lower()
+                                                and is_matched
                                             ):
                                                 if matched_pid is not None:
                                                     # Multiple matches - ambiguous

gobby/agents/runner.py

@@ -49,7 +49,7 @@ class AgentConfig:
     """Machine identifier. Defaults to hostname if not provided."""
 
     source: str = "claude"
-    """CLI source (claude, gemini, codex)."""
+    """CLI source (claude, gemini, codex, cursor, windsurf, copilot)."""
 
     # New spec-aligned parameters
     workflow: str | None = None
@@ -352,6 +352,20 @@ class AgentRunner:
                         ),
                         turns_used=0,
                     )
+                # Agent spawning only supports WorkflowDefinition, not PipelineDefinition
+                if not isinstance(workflow_definition, WorkflowDefinition):
+                    self.logger.error(
+                        f"Cannot use pipeline '{effective_workflow}' for agent spawning"
+                    )
+                    return AgentResult(
+                        output="",
+                        status="error",
+                        error=(
+                            f"'{effective_workflow}' is a pipeline, not a step workflow. "
+                            f"Agent spawning requires a step-based workflow."
+                        ),
+                        turns_used=0,
+                    )
 
         # Create child session (now safe - workflow validated above)
         try:
@@ -377,20 +391,22 @@ class AgentRunner:
             )
 
         # Initialize workflow state if workflow was loaded
+        # workflow_definition is WorkflowDefinition | None at this point (PipelineDefinition rejected above)
         workflow_state = None
-        if workflow_definition:
+        workflow_config: WorkflowDefinition | None = None
+        if workflow_definition and isinstance(workflow_definition, WorkflowDefinition):
+            workflow_config = workflow_definition
             self.logger.info(
-                f"Loaded workflow '{effective_workflow}' for agent "
-                f"(type={workflow_definition.type})"
+                f"Loaded workflow '{effective_workflow}' for agent (type={workflow_config.type})"
             )
 
             # Initialize workflow state for child session
             initial_step = ""
-            if workflow_definition.steps:
-                initial_step = workflow_definition.steps[0].name
+            if workflow_config.steps:
+                initial_step = workflow_config.steps[0].name
 
             # Build initial variables with agent depth information
-            initial_variables = dict(workflow_definition.variables)
+            initial_variables = dict(workflow_config.variables)
             initial_variables["agent_depth"] = child_session.agent_depth
             initial_variables["max_agent_depth"] = self._child_session_manager.max_agent_depth
             initial_variables["can_spawn"] = (
@@ -448,7 +464,7 @@ class AgentRunner:
             session=session_obj,
             run=agent_run,
             workflow_state=workflow_state,
-            workflow_config=workflow_definition,
+            workflow_config=workflow_config,
         )
 
     async def execute_run(

gobby/agents/sandbox.py

@@ -7,6 +7,7 @@ built-in sandbox implementation - Gobby just passes the right flags.
 """
 
 from abc import ABC, abstractmethod
+from pathlib import Path
 from typing import Literal
 
 from pydantic import BaseModel, Field
@@ -202,7 +203,7 @@ def get_sandbox_resolver(cli: str) -> SandboxResolver:
     Factory function to get the appropriate sandbox resolver for a CLI.
 
     Args:
-        cli: The CLI name ("claude", "codex", or "gemini")
+        cli: The CLI name ("claude", "codex", "gemini", "cursor", "windsurf", or "copilot")
 
     Returns:
         The appropriate SandboxResolver subclass instance.
@@ -214,6 +215,9 @@ def get_sandbox_resolver(cli: str) -> SandboxResolver:
         "claude": ClaudeSandboxResolver,
         "codex": CodexSandboxResolver,
         "gemini": GeminiSandboxResolver,
+        "cursor": ClaudeSandboxResolver,
+        "windsurf": ClaudeSandboxResolver,
+        "copilot": ClaudeSandboxResolver,
     }
 
     if cli not in resolvers:
@@ -249,8 +253,9 @@ def compute_sandbox_paths(
         if path not in write_paths:
             write_paths.append(path)
 
-    # Collect read paths
-    read_paths = list(config.extra_read_paths)
+    # Collect read paths - always include ~/.gobby/ for machine_id access
+    gobby_home = str(Path("~/.gobby").expanduser())
+    read_paths = [gobby_home] + list(config.extra_read_paths)
 
     return ResolvedSandboxPaths(
         workspace_path=workspace_path,

gobby/agents/session.py

@@ -53,6 +53,9 @@ class ChildSessionConfig:
     lifecycle_variables: dict[str, Any] | None = None
     """Lifecycle variables for the session."""
 
+    step_variables: dict[str, Any] | None = None
+    """Variables to pass during workflow auto-activation (e.g., assigned_task_id)."""
+
 
 class ChildSessionManager:
     """
@@ -197,6 +200,7 @@ class ChildSessionManager:
             agent_depth=child_depth,
             spawned_by_agent_id=config.agent_id,
             workflow_name=config.workflow_name,
+            step_variables=config.step_variables,
         )
 
         child_id = child.id

gobby/agents/spawn.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
 
 from gobby.agents.constants import get_terminal_env_vars
 from gobby.agents.sandbox import SandboxConfig, compute_sandbox_paths, get_sandbox_resolver
@@ -239,7 +240,7 @@ class TerminalSpawner:
         Spawn a CLI agent in a new terminal with Gobby environment variables.
 
         Args:
-            cli: CLI to run (e.g., "claude", "gemini", "codex")
+            cli: CLI to run (e.g., "claude", "gemini", "codex", "cursor", "windsurf", "copilot")
             cwd: Working directory (usually project root or worktree)
             session_id: Pre-created child session ID
             parent_session_id: Parent session for context resolution
@@ -366,6 +367,7 @@ def prepare_terminal_spawn(
     source: str = "claude",
     agent_id: str | None = None,
     workflow_name: str | None = None,
+    step_variables: dict[str, Any] | None = None,
     title: str | None = None,
     git_branch: str | None = None,
     prompt: str | None = None,
@@ -384,7 +386,7 @@ def prepare_terminal_spawn(
         parent_session_id: Parent session ID
         project_id: Project ID
         machine_id: Machine ID
-        source: CLI source (claude, gemini, codex)
+        source: CLI source (claude, gemini, codex, cursor, windsurf, copilot)
         agent_id: Optional agent ID
         workflow_name: Optional workflow to activate
         title: Optional session title
@@ -408,6 +410,7 @@ def prepare_terminal_spawn(
         source=source,
         agent_id=agent_id,
         workflow_name=workflow_name,
+        step_variables=step_variables,
         title=title,
         git_branch=git_branch,
     )
@@ -460,6 +463,7 @@ async def prepare_gemini_spawn_with_preflight(
     machine_id: str,
     agent_id: str | None = None,
     workflow_name: str | None = None,
+    step_variables: dict[str, Any] | None = None,
     title: str | None = None,
     git_branch: str | None = None,
     prompt: str | None = None,
@@ -512,6 +516,7 @@ async def prepare_gemini_spawn_with_preflight(
         source="gemini",
         agent_id=agent_id,
         workflow_name=workflow_name,
+        step_variables=step_variables,
         title=title,
         git_branch=git_branch,
         external_id=gemini_info.session_id,  # Link to Gemini's session
@@ -569,6 +574,7 @@ async def prepare_codex_spawn_with_preflight(
     machine_id: str,
     agent_id: str | None = None,
     workflow_name: str | None = None,
+    step_variables: dict[str, Any] | None = None,
     title: str | None = None,
     git_branch: str | None = None,
     prompt: str | None = None,
@@ -621,6 +627,7 @@ async def prepare_codex_spawn_with_preflight(
         source="codex",
         agent_id=agent_id,
         workflow_name=workflow_name,
+        step_variables=step_variables,
         title=title,
         git_branch=git_branch,
         external_id=codex_info.session_id,  # Link to Codex's session

gobby/agents/spawn_executor.py

@@ -20,10 +20,10 @@ if TYPE_CHECKING:
     from gobby.agents.session import ChildSessionManager
 from gobby.agents.spawn import (
     TerminalSpawner,
+    build_cli_command,
     build_codex_command_with_resume,
-    build_gemini_command_with_resume,
     prepare_codex_spawn_with_preflight,
-    prepare_gemini_spawn_with_preflight,
+    prepare_terminal_spawn,
 )
 from gobby.agents.spawners.embedded import EmbeddedSpawner
 from gobby.agents.spawners.headless import HeadlessSpawner
@@ -38,7 +38,7 @@ class SpawnRequest:
     # Required fields
     prompt: str
     cwd: str
-    mode: Literal["terminal", "embedded", "headless"]
+    mode: Literal["terminal", "embedded", "headless", "self"]
     provider: str
     terminal: str
     session_id: str
@@ -48,8 +48,10 @@ class SpawnRequest:
 
     # Optional fields
     workflow: str | None = None
+    step_variables: dict[str, Any] | None = None  # Variables for step workflow activation
     worktree_id: str | None = None
     clone_id: str | None = None
+    branch_name: str | None = None  # Git branch for worktree/clone isolation
     agent_depth: int = 0
     max_agent_depth: int = 3
     session_manager: Any | None = None  # Required for Gemini/Codex preflight
@@ -221,15 +223,16 @@ async def _spawn_headless(request: SpawnRequest) -> SpawnResult:
 
 async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
     """
-    Spawn Gemini agent in terminal with preflight session capture.
+    Spawn Gemini agent in terminal with direct spawn (no preflight).
 
-    Uses preflight to capture Gemini's session_id before launching interactive mode:
-    1. Run `gemini --output-format stream-json` to capture Gemini's session_id
-    2. Pre-create Gobby session with parent_session_id linked and external_id set
-    3. Resume Gemini session with `-r {session_id}` flag
+    Session linkage approach:
+    1. Pre-create Gobby session with parent linkage (no external_id yet)
+    2. Pass GOBBY_SESSION_ID and other env vars to the terminal
+    3. Gemini's hook dispatcher reads env vars and includes in SessionStart
+    4. Daemon updates external_id when SessionStart fires with Gemini's native session_id
 
-    This approach ensures session linkage works without relying on env vars,
-    which don't pass through macOS's `open` command.
+    This avoids the preflight+resume approach which failed because Gemini
+    doesn't persist sessions when terminated.
     """
     if request.session_manager is None:
         return SpawnResult(
@@ -237,60 +240,36 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
             run_id=request.run_id,
             child_session_id=None,
             status="failed",
-            error="session_manager is required for Gemini preflight",
+            error="session_manager is required for Gemini spawn",
         )
 
-    try:
-        # Preflight capture: gets Gemini's session_id and creates linked Gobby session
-        spawn_context = await prepare_gemini_spawn_with_preflight(
-            session_manager=cast("ChildSessionManager", request.session_manager),
-            parent_session_id=request.parent_session_id,
-            project_id=request.project_id,
-            machine_id=request.machine_id or "unknown",
-            workflow_name=request.workflow,
-            git_branch=None,  # Will be detected by hook
-            prompt=request.prompt,
-            max_agent_depth=request.max_agent_depth,
-        )
-    except FileNotFoundError as e:
-        logger.error(
-            f"Gemini spawn failed - command not found: {e}",
-            extra={"project_id": request.project_id, "run_id": request.run_id},
-        )
-        return SpawnResult(
-            success=False,
-            run_id=request.run_id,
-            child_session_id=None,
-            status="failed",
-            error=str(e),
-        )
-    except Exception as e:
-        logger.error(
-            f"Gemini preflight capture failed: {e}",
-            extra={"project_id": request.project_id, "run_id": request.run_id},
-            exc_info=True,
-        )
-        return SpawnResult(
-            success=False,
-            run_id=request.run_id,
-            child_session_id=None,
-            status="failed",
-            error=f"Gemini preflight capture failed: {e}",
-        )
+    # Prepare spawn context (creates child session, builds env vars)
+    spawn_context = prepare_terminal_spawn(
+        session_manager=cast("ChildSessionManager", request.session_manager),
+        parent_session_id=request.parent_session_id,
+        project_id=request.project_id,
+        machine_id=request.machine_id or "unknown",
+        source="gemini",
+        workflow_name=request.workflow,
+        step_variables=request.step_variables,
+        prompt=request.prompt,
+        max_agent_depth=request.max_agent_depth,
+        git_branch=request.branch_name,
+    )
 
-    # Extract IDs from prepared spawn context
     gobby_session_id = spawn_context.session_id
-    gemini_session_id = spawn_context.env_vars["GOBBY_GEMINI_EXTERNAL_ID"]
 
-    # Build command with resume (no env vars needed - session already linked)
-    cmd = build_gemini_command_with_resume(
-        gemini_external_id=gemini_session_id,
+    # Build command for fresh Gemini session (not resume)
+    # Session context is injected via additionalContext at SessionStart by the daemon
+    cmd = build_cli_command(
+        cli="gemini",
         prompt=request.prompt,
         auto_approve=True,
-        gobby_session_id=gobby_session_id,
+        mode="terminal",
     )
 
     # Resolve sandbox config if provided
+    sandbox_args: list[str] = []
     sandbox_env: dict[str, str] = {}
     if request.sandbox_config and request.sandbox_config.enabled:
         resolver = GeminiSandboxResolver()
@@ -299,16 +278,25 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
             workspace_path=request.cwd,
         )
         sandbox_args, sandbox_env = resolver.resolve(request.sandbox_config, paths)
-        # Append sandbox args to command (e.g., -s flag)
+        # Append sandbox args to command
         cmd.extend(sandbox_args)
 
-    # Spawn in terminal
+    # Merge env vars: spawn context + sandbox
+    env = spawn_context.env_vars.copy()
+    if sandbox_env:
+        env.update(sandbox_env)
+
+    # Pass machine_id as env var for sandboxed agents that can't read ~/.gobby/machine_id
+    if request.machine_id:
+        env["GOBBY_MACHINE_ID"] = request.machine_id
+
+    # Spawn in terminal with env vars
     terminal_spawner = TerminalSpawner()
     terminal_result = terminal_spawner.spawn(
         command=cmd,
         cwd=request.cwd,
         terminal=request.terminal,
-        env=sandbox_env if sandbox_env else None,
+        env=env,
     )
 
     if not terminal_result.success:
@@ -322,11 +310,10 @@ async def _spawn_gemini_terminal(request: SpawnRequest) -> SpawnResult:
 
     return SpawnResult(
         success=True,
-        run_id=f"gemini-{gemini_session_id[:8]}",
-        child_session_id=gobby_session_id,  # Now properly set!
+        run_id=spawn_context.agent_run_id,
+        child_session_id=gobby_session_id,
         status="pending",
         pid=terminal_result.pid,
-        gemini_session_id=gemini_session_id,
         message=f"Gemini agent spawned in terminal with session {gobby_session_id}",
     )
 
@@ -354,7 +341,8 @@ async def _spawn_codex_terminal(request: SpawnRequest) -> SpawnResult:
             project_id=request.project_id,
             machine_id=request.machine_id or "unknown",
             workflow_name=request.workflow,
-            git_branch=None,  # Will be detected by hook
+            step_variables=request.step_variables,
+            git_branch=request.branch_name,
         )
     except FileNotFoundError as e:
         return SpawnResult(

gobby/agents/spawners/command_builder.py

@@ -35,9 +35,9 @@ def build_cli_command(
     - Or: codex -c 'sandbox_permissions=["disk-full-read-access"]' -a never [PROMPT]
 
     Args:
-        cli: CLI name (claude, gemini, codex)
+        cli: CLI name (claude, gemini, codex, cursor, windsurf, copilot)
         prompt: Optional prompt to pass
-        session_id: Optional session ID (used by Claude CLI)
+        session_id: Optional session ID (used by Claude-compatible CLIs)
         auto_approve: If True, add flags to auto-approve actions/permissions
         working_directory: Optional working directory (used by Codex -C flag)
         mode: Execution mode - "terminal" (interactive) or "headless" (non-interactive)
@@ -48,8 +48,8 @@ def build_cli_command(
     """
     command = [cli]
 
-    if cli == "claude":
-        # Claude CLI flags
+    if cli in ("claude", "cursor", "windsurf", "copilot"):
+        # Claude-compatible CLI flags
         if session_id:
             command.extend(["--session-id", session_id])
         if auto_approve: