gobby 0.2.5__py3-none-any.whl

gobby/agents/spawners/windows.py

@@ -0,0 +1,308 @@
+"""Windows terminal spawners: Windows Terminal, cmd, PowerShell, and WSL."""
+
+from __future__ import annotations
+
+import os
+import platform
+import shlex
+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__ = ["WindowsTerminalSpawner", "CmdSpawner", "PowerShellSpawner", "WSLSpawner"]
+
+
+class WindowsTerminalSpawner(TerminalSpawnerBase):
+    """Spawner for Windows Terminal."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.WINDOWS_TERMINAL
+
+    def is_available(self) -> bool:
+        if platform.system() != "Windows":
+            return False
+        config = get_tty_config().get_terminal_config("windows-terminal")
+        if not config.enabled:
+            return False
+        command = config.command or "wt"
+        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("windows-terminal")
+            cli_command = tty_config.command or "wt"
+            args = [cli_command, "-d", str(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,
+                creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned Windows 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 Windows Terminal: {e}",
+                error=str(e),
+            )
+
+
+class CmdSpawner(TerminalSpawnerBase):
+    """Spawner for Windows cmd.exe."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.CMD
+
+    def is_available(self) -> bool:
+        if platform.system() != "Windows":
+            return False
+        config = get_tty_config().get_terminal_config("cmd")
+        return config.enabled
+
+    def spawn(
+        self,
+        command: list[str],
+        cwd: str | Path,
+        env: dict[str, str] | None = None,
+        title: str | None = None,
+    ) -> SpawnResult:
+        try:
+            # Build the inner command as a list and convert safely with list2cmdline
+            # This properly escapes all arguments to prevent command injection
+            cd_cmd = ["cd", "/d", str(cwd)]
+            # Build full command list: cd /d path && original_command
+            # list2cmdline handles proper escaping for Windows
+            inner_cmd = subprocess.list2cmdline(cd_cmd) + " && " + subprocess.list2cmdline(command)
+
+            args = ["cmd", "/c", "start"]
+            if title:
+                # Title must be quoted if it contains spaces
+                args.append(subprocess.list2cmdline([title]))
+            # Use empty title if none provided (required for start command when path is quoted)
+            else:
+                args.append('""')
+            # Pass the inner command as a single argument to cmd /k
+            args.extend(["cmd", "/k", inner_cmd])
+
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                env=spawn_env,
+                creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned cmd.exe 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 cmd.exe: {e}",
+                error=str(e),
+            )
+
+
+class PowerShellSpawner(TerminalSpawnerBase):
+    """Spawner for Windows PowerShell."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.POWERSHELL
+
+    def is_available(self) -> bool:
+        if platform.system() != "Windows":
+            return False
+        config = get_tty_config().get_terminal_config("powershell")
+        if not config.enabled:
+            return False
+        # Check for pwsh (PowerShell Core) first, then powershell (Windows PowerShell)
+        command = config.command or "pwsh"
+        if shutil.which(command) is not None:
+            return True
+        # Fall back to Windows PowerShell
+        return shutil.which("powershell") 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("powershell")
+            # Prefer pwsh (PowerShell Core) over powershell (Windows PowerShell)
+            cli_command = tty_config.command or "pwsh"
+            if shutil.which(cli_command) is None:
+                cli_command = "powershell"
+
+            # Build the inner command to run
+            # PowerShell requires special escaping for the -Command parameter
+            inner_cmd = subprocess.list2cmdline(command)
+
+            # Escape values for PowerShell single-quoted strings (double any single quotes)
+            safe_cwd = "'" + str(cwd).replace("'", "''") + "'"
+            safe_inner_cmd = inner_cmd.replace("'", "''")
+
+            # Build PowerShell command:
+            # Start-Process spawns a new window, -WorkingDirectory sets cwd
+            # -NoExit keeps the window open after command completes
+            ps_script = f"Set-Location -Path {safe_cwd}; {safe_inner_cmd}"
+
+            args = ["cmd", "/c", "start", "", cli_command]
+            # Add extra options from config
+            args.extend(tty_config.options)
+            if title:
+                # Escape title for PowerShell
+                safe_title = "'" + title.replace("'", "''") + "'"
+                args.extend(["-Title", safe_title])
+            args.extend(["-NoExit", "-Command", ps_script])
+
+            spawn_env = os.environ.copy()
+            if env:
+                spawn_env.update(env)
+
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                env=spawn_env,
+                creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned PowerShell 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 PowerShell: {e}",
+                error=str(e),
+            )
+
+
+class WSLSpawner(TerminalSpawnerBase):
+    """Spawner for Windows Subsystem for Linux (WSL2)."""
+
+    @property
+    def terminal_type(self) -> TerminalType:
+        return TerminalType.WSL
+
+    def is_available(self) -> bool:
+        if platform.system() != "Windows":
+            return False
+        config = get_tty_config().get_terminal_config("wsl")
+        if not config.enabled:
+            return False
+        command = config.command or "wsl"
+        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("wsl")
+            cli_command = tty_config.command or "wsl"
+
+            # Convert Windows path to WSL path if needed
+            # e.g., C:\Users\foo -> /mnt/c/Users/foo
+            cwd_str = str(cwd)
+            if len(cwd_str) >= 2 and cwd_str[1] == ":":
+                # Windows absolute path - convert to WSL format
+                drive = cwd_str[0].lower()
+                wsl_path = f"/mnt/{drive}{cwd_str[2:].replace(chr(92), '/')}"
+            else:
+                wsl_path = cwd_str
+
+            # Build the command to run inside WSL
+            # Escape for bash shell inside WSL
+            inner_parts = [shlex.quote(part) for part in command]
+            inner_cmd = " ".join(inner_parts)
+            wsl_script = f"cd {shlex.quote(wsl_path)} && {inner_cmd}"
+
+            # Build environment exports for WSL
+            env_exports = ""
+            if env:
+                exports = []
+                for k, v in env.items():
+                    if k.isidentifier():
+                        exports.append(f"export {k}={shlex.quote(v)}")
+                if exports:
+                    env_exports = " && ".join(exports) + " && "
+
+            full_script = env_exports + wsl_script
+
+            # Use cmd /c start to spawn in a new console window
+            args = ["cmd", "/c", "start"]
+            if title:
+                args.append(subprocess.list2cmdline([title]))
+            else:
+                args.append('""')
+            args.extend([cli_command])
+            # Add extra options from config (e.g., -d for distribution)
+            args.extend(tty_config.options)
+            args.extend(["--", "bash", "-c", full_script])
+
+            spawn_env = os.environ.copy()
+            # Note: env vars passed via spawn_env won't reach WSL directly
+            # They're handled via the bash -c script above
+
+            process = subprocess.Popen(  # nosec B603 - args built from config
+                args,
+                env=spawn_env,
+                creationflags=getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0),
+            )
+
+            return SpawnResult(
+                success=True,
+                message=f"Spawned WSL 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 WSL: {e}",
+                error=str(e),
+            )

gobby/agents/tty_config.py

@@ -0,0 +1,319 @@
+"""
+Terminal spawner configuration.
+
+Loads terminal preferences and customizations from ~/.gobby/tty_config.yaml,
+allowing users to reorder preferences, customize app paths, and add options.
+"""
+
+from __future__ import annotations
+
+import platform
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class TerminalConfig(BaseModel):
+    """Configuration for a specific terminal emulator."""
+
+    app_path: str | None = Field(
+        default=None,
+        description="macOS app bundle path (e.g., /Applications/Ghostty.app)",
+    )
+    command: str | None = Field(
+        default=None,
+        description="CLI command name for shutil.which() (e.g., ghostty, kitty)",
+    )
+    options: list[str] = Field(
+        default_factory=list,
+        description="Extra command-line options to pass to the terminal",
+    )
+    enabled: bool = Field(
+        default=True,
+        description="Whether this terminal is enabled for use",
+    )
+
+
+class PlatformPreferences(BaseModel):
+    """Terminal preference order by platform."""
+
+    macos: list[str] = Field(
+        default_factory=lambda: [
+            "ghostty",
+            "iterm",
+            "kitty",
+            "alacritty",
+            "terminal.app",
+            "tmux",  # Multiplexer (last resort)
+        ],
+        description="Terminal preference order for macOS",
+    )
+    linux: list[str] = Field(
+        default_factory=lambda: [
+            "ghostty",
+            "kitty",
+            "gnome-terminal",
+            "konsole",
+            "alacritty",
+            "tmux",  # Multiplexer (last resort)
+        ],
+        description="Terminal preference order for Linux",
+    )
+    windows: list[str] = Field(
+        default_factory=lambda: [
+            "windows-terminal",
+            "powershell",
+            "alacritty",
+            "wsl",
+            "cmd",
+        ],
+        description="Terminal preference order for Windows",
+    )
+
+
+# Default terminal configurations (can be overridden in config file)
+DEFAULT_TERMINAL_CONFIGS: dict[str, dict[str, Any]] = {
+    "ghostty": {
+        "app_path": "/Applications/Ghostty.app",
+        "command": "ghostty",
+    },
+    "iterm": {
+        "app_path": "/Applications/iTerm.app",
+    },
+    "terminal.app": {
+        "app_path": "/System/Applications/Utilities/Terminal.app",
+    },
+    "kitty": {
+        "app_path": "/Applications/kitty.app",
+        "command": "kitty",
+        "options": ["-o", "confirm_os_window_close=0"],
+    },
+    "alacritty": {
+        "command": "alacritty",
+    },
+    "gnome-terminal": {
+        "command": "gnome-terminal",
+    },
+    "konsole": {
+        "command": "konsole",
+    },
+    "windows-terminal": {
+        "command": "wt",
+    },
+    "cmd": {
+        # Built-in on Windows, no command needed
+    },
+    "powershell": {
+        # pwsh (PowerShell Core) is preferred, falls back to powershell (Windows PowerShell)
+        "command": "pwsh",
+    },
+    "wsl": {
+        "command": "wsl",
+        # Options can specify distribution: ["-d", "Ubuntu"]
+    },
+    "tmux": {
+        "command": "tmux",
+        # Options can set socket name, config file, etc.
+    },
+}
+
+
+class TTYConfig(BaseModel):
+    """Terminal spawner configuration."""
+
+    preferences: PlatformPreferences = Field(
+        default_factory=PlatformPreferences,
+        description="Terminal preference order by platform",
+    )
+    terminals: dict[str, TerminalConfig] = Field(
+        default_factory=dict,
+        description="Terminal-specific configurations (merged with defaults)",
+    )
+
+    def get_terminal_config(self, terminal_name: str) -> TerminalConfig:
+        """
+        Get configuration for a specific terminal.
+
+        Merges user config with defaults, with user config taking precedence.
+
+        Args:
+            terminal_name: Name of the terminal (e.g., 'ghostty', 'iterm')
+
+        Returns:
+            TerminalConfig with merged settings
+        """
+        # Start with defaults
+        defaults = DEFAULT_TERMINAL_CONFIGS.get(terminal_name, {})
+        config_dict = dict(defaults)
+
+        # Merge user config if present
+        if terminal_name in self.terminals:
+            user_config = self.terminals[terminal_name].model_dump(exclude_none=True)
+            # For options, extend rather than replace
+            if "options" in user_config and "options" in config_dict:
+                config_dict["options"] = config_dict["options"] + user_config["options"]
+                del user_config["options"]
+            config_dict.update(user_config)
+
+        return TerminalConfig(**config_dict)
+
+    def get_preferences(self) -> list[str]:
+        """
+        Get terminal preference order for current platform.
+
+        Returns:
+            List of terminal names in preference order
+        """
+        system = platform.system()
+        if system == "Darwin":
+            return self.preferences.macos
+        elif system == "Windows":
+            return self.preferences.windows
+        else:
+            return self.preferences.linux
+
+
+def load_tty_config(config_path: str | Path | None = None) -> TTYConfig:
+    """
+    Load terminal configuration from YAML file.
+
+    Args:
+        config_path: Path to config file (default: ~/.gobby/tty_config.yaml)
+
+    Returns:
+        TTYConfig instance (with defaults if file doesn't exist)
+    """
+    if config_path is None:
+        config_path = Path.home() / ".gobby" / "tty_config.yaml"
+    else:
+        config_path = Path(config_path).expanduser()
+
+    if not config_path.exists():
+        return TTYConfig()
+
+    try:
+        with open(config_path) as f:
+            data = yaml.safe_load(f)
+        return TTYConfig(**(data or {}))
+    except Exception:
+        # Fall back to defaults on any error
+        return TTYConfig()
+
+
+def generate_default_tty_config(config_path: str | Path | None = None) -> Path:
+    """
+    Generate default terminal configuration file.
+
+    Args:
+        config_path: Path to config file (default: ~/.gobby/tty_config.yaml)
+
+    Returns:
+        Path to the created config file
+    """
+    if config_path is None:
+        config_path = Path.home() / ".gobby" / "tty_config.yaml"
+    else:
+        config_path = Path(config_path).expanduser()
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Generate example config with comments
+    config_content = """# Terminal spawner configuration for Gobby
+# See: https://github.com/GobbyAI/gobby/docs/terminal-config.md
+
+# Terminal preference order by platform (first available is used)
+preferences:
+  macos:
+    - ghostty
+    - iterm
+    - kitty
+    - alacritty
+    - terminal.app
+    - tmux
+  linux:
+    - ghostty
+    - kitty
+    - gnome-terminal
+    - konsole
+    - alacritty
+    - tmux
+  windows:
+    - windows-terminal
+    - powershell
+    - alacritty
+    - wsl
+    - cmd
+
+# Terminal-specific configurations (overrides defaults)
+# Uncomment and modify as needed:
+#
+# terminals:
+#   ghostty:
+#     app_path: /Applications/Ghostty.app  # macOS app bundle path
+#     command: ghostty                      # CLI command (Linux/other)
+#     enabled: true                         # Set to false to skip this terminal
+#
+#   kitty:
+#     app_path: /Applications/kitty.app
+#     command: kitty
+#     options:                              # Extra command-line options
+#       - "-o"
+#       - "confirm_os_window_close=0"
+#
+#   iterm:
+#     app_path: /Applications/iTerm.app
+#
+#   powershell:
+#     command: pwsh                         # Use 'powershell' for Windows PowerShell
+#
+#   wsl:
+#     command: wsl
+#     options:                              # Specify WSL distribution
+#       - "-d"
+#       - "Ubuntu"
+#
+#   tmux:
+#     command: tmux
+#     options:                              # Use specific socket/config
+#       - "-L"
+#       - "gobby"
+"""
+
+    with open(config_path, "w") as f:
+        f.write(config_content)
+
+    # Set restrictive permissions
+    config_path.chmod(0o600)
+
+    return config_path
+
+
+# Global cached config instance
+_config: TTYConfig | None = None
+
+
+def get_tty_config() -> TTYConfig:
+    """
+    Get the terminal configuration (cached).
+
+    Returns:
+        TTYConfig instance
+    """
+    global _config
+    if _config is None:
+        _config = load_tty_config()
+    return _config
+
+
+def reload_tty_config() -> TTYConfig:
+    """
+    Reload terminal configuration from disk.
+
+    Returns:
+        New TTYConfig instance
+    """
+    global _config
+    _config = load_tty_config()
+    return _config

gobby/autonomous/__init__.py

@@ -0,0 +1,32 @@
+"""Autonomous execution infrastructure for Gobby.
+
+This module provides infrastructure for autonomous task execution including:
+- Stop signal management for graceful shutdown
+- Progress tracking for detecting stagnation
+- Stuck detection for breaking out of loops
+"""
+
+from gobby.autonomous.progress_tracker import (
+    ProgressEvent,
+    ProgressSummary,
+    ProgressTracker,
+    ProgressType,
+)
+from gobby.autonomous.stop_registry import StopRegistry, StopSignal
+from gobby.autonomous.stuck_detector import (
+    StuckDetectionResult,
+    StuckDetector,
+    TaskSelectionEvent,
+)
+
+__all__ = [
+    "ProgressEvent",
+    "ProgressSummary",
+    "ProgressTracker",
+    "ProgressType",
+    "StopRegistry",
+    "StopSignal",
+    "StuckDetectionResult",
+    "StuckDetector",
+    "TaskSelectionEvent",
+]