gobby 0.2.5__py3-none-any.whl

gobby/agents/spawners/headless.py

@@ -0,0 +1,226 @@
+"""Headless spawner for agent execution with output capture."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess  # nosec B404 - subprocess needed for headless agent spawning
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from gobby.agents.constants import get_terminal_env_vars
+from gobby.agents.spawners.base import HeadlessResult
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+__all__ = ["HeadlessSpawner"]
+
+
+# Import these from spawn.py to avoid duplication
+def _get_spawn_utils() -> tuple[
+    Callable[..., list[str]],
+    Callable[[str, str], str],
+    int,
+]:
+    """Lazy import to avoid circular dependencies."""
+    from gobby.agents.spawn import (
+        MAX_ENV_PROMPT_LENGTH,
+        _create_prompt_file,
+        build_cli_command,
+    )
+
+    return build_cli_command, _create_prompt_file, MAX_ENV_PROMPT_LENGTH
+
+
+class HeadlessSpawner:
+    """
+    Spawner for headless mode with output capture.
+
+    Runs the process without a visible terminal, capturing all output
+    to a buffer that can be stored in the session transcript.
+    """
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+    ) -> HeadlessResult:
+        """
+        Spawn a headless process with output capture.
+
+        Args:
+            command: Command to run
+            cwd: Working directory
+            env: Environment variables to set
+
+        Returns:
+            HeadlessResult with process handle for output capture
+        """
+        try:
+            # Merge environment
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            # Spawn process with captured output
+            # Use DEVNULL for stdin since headless mode uses -p flag (print mode)
+            # which reads prompt from CLI args, not stdin. A pipe stdin would hang.
+            process = subprocess.Popen(  # nosec B603 - command built from config
+                command,
+                cwd=cwd,
+                env=spawn_env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                stdin=subprocess.DEVNULL,
+                text=True,
+                bufsize=1,  # Line buffered
+            )
+
+            return HeadlessResult(
+                success=True,
+                message=f"Spawned headless process with PID {process.pid}",
+                pid=process.pid,
+                process=process,
+            )
+
+        except Exception as e:
+            return HeadlessResult(
+                success=False,
+                message=f"Failed to spawn headless process: {e}",
+                error=str(e),
+            )
+
+    async def spawn_and_capture(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        timeout: float | None = None,
+        on_output: Callable[[str], None] | None = None,
+    ) -> HeadlessResult:
+        """
+        Spawn a headless process and capture output asynchronously.
+
+        Args:
+            command: Command to run
+            cwd: Working directory
+            env: Environment variables to set
+            timeout: Optional timeout in seconds
+            on_output: Optional callback for each line of output
+
+        Returns:
+            HeadlessResult with captured output
+        """
+        result = self.spawn(command, cwd, env)
+        if not result.success or result.process is None:
+            return result
+
+        try:
+            # Read output asynchronously
+            async def read_output() -> None:
+                if result.process and result.process.stdout:
+                    loop = asyncio.get_running_loop()
+                    while True:
+                        line = await loop.run_in_executor(None, result.process.stdout.readline)
+                        if not line:
+                            break
+                        line = line.rstrip("\n")
+                        result.output_buffer.append(line)
+                        if on_output:
+                            on_output(line)
+
+            if timeout:
+                await asyncio.wait_for(read_output(), timeout=timeout)
+            else:
+                await read_output()
+
+            # Wait for process to complete without blocking the event loop
+            if result.process:
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(None, result.process.wait)
+
+        except TimeoutError:
+            if result.process:
+                result.process.terminate()
+                # Also wait for termination to complete (non-blocking)
+                try:
+                    loop = asyncio.get_running_loop()
+                    await loop.run_in_executor(None, result.process.wait)
+                except Exception:
+                    pass  # nosec B110 - Best-effort process cleanup
+            result.error = "Process timed out"
+
+        except Exception as e:
+            result.error = str(e)
+
+        return result
+
+    def spawn_agent(
+        self,
+        cli: str,
+        cwd: str | Path,
+        session_id: str,
+        parent_session_id: str,
+        agent_run_id: str,
+        project_id: str,
+        workflow_name: str | None = None,
+        agent_depth: int = 1,
+        max_agent_depth: int = 3,
+        prompt: str | None = None,
+    ) -> HeadlessResult:
+        """
+        Spawn a CLI agent in headless mode.
+
+        Args:
+            cli: CLI to run
+            cwd: Working directory
+            session_id: Pre-created child session ID
+            parent_session_id: Parent session ID
+            agent_run_id: Agent run record ID
+            project_id: Project ID
+            workflow_name: Optional workflow to activate
+            agent_depth: Current nesting depth
+            max_agent_depth: Maximum allowed depth
+            prompt: Optional initial prompt
+
+        Returns:
+            HeadlessResult with process handle
+        """
+        build_cli_command, _create_prompt_file, max_env_prompt_length = _get_spawn_utils()
+
+        # Build command with prompt as CLI argument and auto-approve for autonomous work
+        command = build_cli_command(
+            cli,
+            prompt=prompt,
+            session_id=session_id,
+            auto_approve=True,  # Subagents need to work autonomously
+            working_directory=str(cwd) if cli == "codex" else None,
+            mode="headless",  # Non-interactive headless mode
+        )
+
+        # Handle prompt for environment variables (backup for hooks/context)
+        prompt_env: str | None = None
+        prompt_file: str | None = None
+
+        if prompt:
+            if len(prompt) <= max_env_prompt_length:
+                prompt_env = prompt
+            else:
+                # Write to temp file with secure permissions
+                prompt_file = _create_prompt_file(prompt, session_id)
+
+        env = get_terminal_env_vars(
+            session_id=session_id,
+            parent_session_id=parent_session_id,
+            agent_run_id=agent_run_id,
+            project_id=project_id,
+            workflow_name=workflow_name,
+            agent_depth=agent_depth,
+            max_agent_depth=max_agent_depth,
+            prompt=prompt_env,
+            prompt_file=prompt_file,
+        )
+
+        return self.spawn(command, cwd, env)

gobby/agents/spawners/linux.py

@@ -0,0 +1,125 @@
+"""Linux terminal spawners: GNOME Terminal and Konsole."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess  # nosec B404 - subprocess needed for terminal spawning
+from pathlib import Path
+
+from gobby.agents.spawners.base import SpawnResult, TerminalSpawnerBase, TerminalType
+from gobby.agents.tty_config import get_tty_config
+
+__all__ = ["GnomeTerminalSpawner", "KonsoleSpawner"]
+
+
+class GnomeTerminalSpawner(TerminalSpawnerBase):
+    """Spawner for GNOME Terminal."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.GNOME_TERMINAL
+
+    def is_available(self) -> bool:
+        config = get_tty_config().get_terminal_config("gnome-terminal")
+        if not config.enabled:
+            return False
+        command = config.command or "gnome-terminal"
+        return shutil.which(command) is not None
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            tty_config = get_tty_config().get_terminal_config("gnome-terminal")
+            cli_command = tty_config.command or "gnome-terminal"
+            args = [cli_command, f"--working-directory={cwd}"]
+            # Add extra options from config
+            args.extend(tty_config.options)
+            if title:
+                args.extend(["--title", title])
+            args.extend(["--", *command])
+
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                env=spawn_env,
+                start_new_session=True,
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned GNOME Terminal with PID {process.pid}",
+                pid=process.pid,
+                terminal_type=self.terminal_type.value,
+            )
+
+        except Exception as e:
+            return SpawnResult(
+                success=False,
+                message=f"Failed to spawn GNOME Terminal: {e}",
+                error=str(e),
+            )
+
+
+class KonsoleSpawner(TerminalSpawnerBase):
+    """Spawner for KDE Konsole."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.KONSOLE
+
+    def is_available(self) -> bool:
+        config = get_tty_config().get_terminal_config("konsole")
+        if not config.enabled:
+            return False
+        command = config.command or "konsole"
+        return shutil.which(command) is not None
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            tty_config = get_tty_config().get_terminal_config("konsole")
+            cli_command = tty_config.command or "konsole"
+            args = [cli_command, "--workdir", str(cwd)]
+            # Add extra options from config
+            args.extend(tty_config.options)
+            if title:
+                args.extend(["-p", f"tabtitle={title}"])
+            args.extend(["-e", *command])
+
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                env=spawn_env,
+                start_new_session=True,
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned Konsole with PID {process.pid}",
+                pid=process.pid,
+                terminal_type=self.terminal_type.value,
+            )
+
+        except Exception as e:
+            return SpawnResult(
+                success=False,
+                message=f"Failed to spawn Konsole: {e}",
+                error=str(e),
+            )

gobby/agents/spawners/macos.py

@@ -0,0 +1,277 @@
+"""macOS terminal spawners: Ghostty, iTerm2, and Terminal.app."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shlex
+import shutil
+import subprocess  # nosec B404 - subprocess needed for terminal spawning
+import tempfile
+from pathlib import Path
+
+from gobby.agents.spawners.base import SpawnResult, TerminalSpawnerBase, TerminalType
+from gobby.agents.tty_config import get_tty_config
+
+__all__ = ["GhosttySpawner", "ITermSpawner", "TerminalAppSpawner"]
+
+
+def escape_applescript(s: str) -> str:
+    """Escape special characters for embedding in AppleScript strings.
+
+    AppleScript uses backslash escaping for quotes and backslashes.
+    """
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+class GhosttySpawner(TerminalSpawnerBase):
+    """Spawner for Ghostty terminal."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.GHOSTTY
+
+    def is_available(self) -> bool:
+        config = get_tty_config().get_terminal_config("ghostty")
+        if not config.enabled:
+            return False
+        # On macOS, check for the app bundle; on other platforms check CLI
+        if platform.system() == "Darwin":
+            app_path = config.app_path or "/Applications/Ghostty.app"
+            return Path(app_path).exists()
+        command = config.command or "ghostty"
+        return shutil.which(command) is not None
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            tty_config = get_tty_config().get_terminal_config("ghostty")
+            # On macOS, ghostty CLI doesn't support launching the emulator directly
+            # Must use 'open -na Ghostty.app --args' instead
+            # Note: Ghostty requires --key=value syntax, not --key value
+            if platform.system() == "Darwin":
+                app_path = tty_config.app_path or "/Applications/Ghostty.app"
+                # Build args for open command
+                # open -na /path/to/Ghostty.app --args [ghostty-options] -e [command]
+                # Note: 'open' doesn't pass cwd, so we must use --working-directory
+                ghostty_args = [f"--working-directory={cwd}"]
+                if title:
+                    ghostty_args.append(f"--title={title}")
+                # Add any extra options from config
+                ghostty_args.extend(tty_config.options)
+                ghostty_args.extend(["-e"] + command)
+
+                args = ["open", "-na", app_path, "--args"] + ghostty_args
+            else:
+                # On Linux/other platforms, use ghostty CLI directly
+                cli_command = tty_config.command or "ghostty"
+                args = [cli_command]
+                if title:
+                    args.append(f"--title={title}")
+                # Add any extra options from config
+                args.extend(tty_config.options)
+                args.extend(["-e"] + command)
+
+            # Merge environment
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            # Spawn process
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                cwd=cwd,
+                env=spawn_env,
+                start_new_session=True,
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned Ghostty with PID {process.pid}",
+                pid=process.pid,
+                terminal_type=self.terminal_type.value,
+            )
+
+        except Exception as e:
+            return SpawnResult(
+                success=False,
+                message=f"Failed to spawn Ghostty: {e}",
+                error=str(e),
+            )
+
+
+class ITermSpawner(TerminalSpawnerBase):
+    """Spawner for iTerm2 on macOS."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.ITERM
+
+    def is_available(self) -> bool:
+        if platform.system() != "Darwin":
+            return False
+        config = get_tty_config().get_terminal_config("iterm")
+        if not config.enabled:
+            return False
+        app_path = config.app_path or "/Applications/iTerm.app"
+        return Path(app_path).exists()
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            # Write command to a temp script to avoid escaping issues
+            # This is the most reliable way to pass complex commands to iTerm
+            script_content = "#!/bin/bash\n"
+            script_content += f"cd {shlex.quote(str(cwd))}\n"
+            if env:
+                for k, v in env.items():
+                    if k.isidentifier():
+                        script_content += f"export {k}={shlex.quote(v)}\n"
+            script_content += shlex.join(command) + "\n"
+            script_content += "exit\n"  # Exit shell so terminal window closes
+
+            # Create temp script file
+            script_dir = Path(tempfile.gettempdir()) / "gobby-scripts"
+            script_dir.mkdir(parents=True, exist_ok=True)
+            script_path = script_dir / f"iterm-{os.getpid()}-{id(command)}.sh"
+            script_path.write_text(script_content)
+            script_path.chmod(0o755)
+
+            # Check if iTerm was running before we launch it
+            # If running: create new window with command
+            # If not running: use the default window that gets auto-created
+            # Escape script_path to prevent AppleScript injection
+            safe_script_path = escape_applescript(str(script_path))
+            applescript = f"""
+            set iTermWasRunning to application "iTerm" is running
+            tell application "iTerm"
+                activate
+                if iTermWasRunning then
+                    -- iTerm already running, create a new window
+                    create window with default profile command "{safe_script_path}"
+                else
+                    -- iTerm just launched, use the default window
+                    -- Wait for shell to be ready, then exec script (replaces shell so it closes when done)
+                    delay 0.5
+                    tell current session of current window
+                        write text "exec {safe_script_path}"
+                    end tell
+                end if
+            end tell
+            """
+
+            process = subprocess.Popen(  # nosec B603 - osascript with internal AppleScript
+                ["/usr/bin/osascript", "-e", applescript],
+                start_new_session=True,
+            )
+
+            return SpawnResult(
+                success=True,
+                message="Spawned iTerm window",
+                pid=process.pid,
+                terminal_type=self.terminal_type.value,
+            )
+
+        except Exception as e:
+            return SpawnResult(
+                success=False,
+                message=f"Failed to spawn iTerm: {e}",
+                error=str(e),
+            )
+
+
+class TerminalAppSpawner(TerminalSpawnerBase):
+    """Spawner for Terminal.app on macOS."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.TERMINAL_APP
+
+    def is_available(self) -> bool:
+        if platform.system() != "Darwin":
+            return False
+        config = get_tty_config().get_terminal_config("terminal.app")
+        if not config.enabled:
+            return False
+        app_path = config.app_path or "/System/Applications/Utilities/Terminal.app"
+        return Path(app_path).exists()
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            # Build AppleScript for Terminal.app with proper escaping
+            # Shell-quote the command to prevent injection
+            cmd_str = shlex.join(command)
+
+            # Shell-quote environment variable assignments
+            env_exports = ""
+            if env:
+                # Quote both keys and values to prevent injection
+                exports = []
+                for k, v in env.items():
+                    # Validate key is a valid shell variable name
+                    if k.isidentifier():
+                        exports.append(f"export {k}={shlex.quote(v)};")
+                env_exports = " ".join(exports)
+
+            # Quote cwd for shell
+            safe_cwd = shlex.quote(str(cwd))
+
+            shell_command = f"cd {safe_cwd} && {env_exports} {cmd_str}"
+            safe_shell_command = escape_applescript(shell_command)
+
+            # Check if Terminal was running before we launch it
+            # If running: do script creates a new window (correct behavior)
+            # If not running: Terminal opens a default window on launch, so we use that
+            # instead of calling do script (which would open a second window)
+            script = f"""
+            set termWasRunning to application "Terminal" is running
+            tell application "Terminal"
+                activate
+                if termWasRunning then
+                    -- Terminal already running, create a new window
+                    do script "{safe_shell_command}"
+                else
+                    -- Terminal just launched, use the default window
+                    -- Wait for shell to be ready, then exec our command
+                    delay 0.3
+                    tell front window
+                        do script "{safe_shell_command}" in selected tab
+                    end tell
+                end if
+            end tell
+            """
+
+            process = subprocess.Popen(  # nosec B603 - osascript with internal AppleScript
+                ["/usr/bin/osascript", "-e", script],
+                start_new_session=True,
+            )
+
+            return SpawnResult(
+                success=True,
+                message="Spawned Terminal.app window",
+                pid=process.pid,
+                terminal_type=self.terminal_type.value,
+            )
+
+        except Exception as e:
+            return SpawnResult(
+                success=False,
+                message=f"Failed to spawn Terminal.app: {e}",
+                error=str(e),
+            )