agent-cli 0.70.5__py3-none-any.whl

agent_cli/dev/terminals/__init__.py

@@ -0,0 +1,19 @@
+"""Terminal adapters for the dev module."""
+
+from __future__ import annotations
+
+from .base import Terminal
+from .registry import (
+    detect_current_terminal,
+    get_all_terminals,
+    get_available_terminals,
+    get_terminal,
+)
+
+__all__ = [
+    "Terminal",
+    "detect_current_terminal",
+    "get_all_terminals",
+    "get_available_terminals",
+    "get_terminal",
+]

agent_cli/dev/terminals/apple_terminal.py

@@ -0,0 +1,82 @@
+"""macOS Terminal.app adapter."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+from .base import Terminal, _get_term_program
+
+
+class AppleTerminal(Terminal):
+    """macOS Terminal.app - the default macOS terminal."""
+
+    name = "terminal"
+
+    def detect(self) -> bool:
+        """Detect if running inside Terminal.app."""
+        term_program = _get_term_program()
+        return term_program == "Apple_Terminal"
+
+    def is_available(self) -> bool:
+        """Check if Terminal.app is available (macOS only)."""
+        if sys.platform != "darwin":
+            return False
+        # Terminal.app is always available on macOS
+        return Path("/System/Applications/Utilities/Terminal.app").exists()
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in Terminal.app using AppleScript.
+
+        Requires System Events accessibility permissions in
+        System Preferences > Privacy & Security > Accessibility.
+        """
+        if not self.is_available():
+            return False
+
+        def escape_applescript(s: str) -> str:
+            """Escape string for AppleScript double-quoted string."""
+            return s.replace("\\", "\\\\").replace('"', '\\"')
+
+        # Build the command to run
+        shell_cmd = f'cd "{path}" && {command}' if command else f'cd "{path}"'
+        shell_cmd_escaped = escape_applescript(shell_cmd)
+
+        # Build custom title command if provided
+        title_cmd = ""
+        if tab_name:
+            tab_name_escaped = escape_applescript(tab_name)
+            title_cmd = (
+                f'\nset custom title of selected tab of front window to "{tab_name_escaped}"'
+            )
+
+        # AppleScript to open new tab in Terminal.app using System Events
+        applescript = f"""
+            tell application "Terminal"
+                activate
+            end tell
+            tell application "System Events"
+                keystroke "t" using command down
+            end tell
+            delay 0.3
+            tell application "Terminal"
+                do script "{shell_cmd_escaped}" in selected tab of front window{title_cmd}
+            end tell
+        """
+
+        try:
+            subprocess.run(
+                ["osascript", "-e", applescript],  # noqa: S607
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            return True
+        except subprocess.CalledProcessError:
+            return False

agent_cli/dev/terminals/base.py

@@ -0,0 +1,56 @@
+"""Base class for terminal adapters."""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Terminal(ABC):
+    """Abstract base class for terminal adapters."""
+
+    # Display name for the terminal
+    name: str
+
+    @abstractmethod
+    def detect(self) -> bool:
+        """Check if currently running inside this terminal.
+
+        This is used to auto-detect which terminal to use.
+        """
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this terminal is installed and available."""
+
+    @abstractmethod
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in this terminal.
+
+        Args:
+            path: The directory to open in
+            command: Optional command to run in the new tab
+            tab_name: Optional name for the new tab
+
+        Returns:
+            True if successful, False otherwise
+
+        """
+
+    def __repr__(self) -> str:  # noqa: D105
+        status = "available" if self.is_available() else "not installed"
+        return f"<{self.__class__.__name__} {self.name!r} ({status})>"
+
+
+def _get_term_program() -> str | None:
+    """Get the TERM_PROGRAM environment variable."""
+    return os.environ.get("TERM_PROGRAM")

agent_cli/dev/terminals/gnome.py

@@ -0,0 +1,51 @@
+"""GNOME Terminal adapter."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from .base import Terminal
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class GnomeTerminal(Terminal):
+    """GNOME Terminal - Default terminal for GNOME desktop."""
+
+    name = "gnome-terminal"
+
+    def detect(self) -> bool:
+        """Detect if running inside GNOME Terminal."""
+        return os.environ.get("GNOME_TERMINAL_SERVICE") is not None
+
+    def is_available(self) -> bool:
+        """Check if GNOME Terminal is available."""
+        return shutil.which("gnome-terminal") is not None
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in GNOME Terminal."""
+        if not self.is_available():
+            return False
+
+        cmd = ["gnome-terminal", "--tab", f"--working-directory={path}"]
+
+        if tab_name:
+            cmd.extend(["--title", tab_name])
+
+        if command:
+            cmd.extend(["--", "bash", "-c", f"{command}; exec bash"])
+
+        try:
+            subprocess.Popen(cmd)
+            return True
+        except Exception:
+            return False

agent_cli/dev/terminals/iterm2.py

@@ -0,0 +1,84 @@
+"""iTerm2 terminal adapter."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from .base import Terminal, _get_term_program
+
+
+class ITerm2(Terminal):
+    """iTerm2 - macOS terminal emulator with advanced features."""
+
+    name = "iterm2"
+
+    def detect(self) -> bool:
+        """Detect if running inside iTerm2."""
+        # Check TERM_PROGRAM
+        term_program = _get_term_program()
+        if term_program and "iterm" in term_program.lower():
+            return True
+        # Check iTerm-specific env var
+        return os.environ.get("ITERM_SESSION_ID") is not None
+
+    def is_available(self) -> bool:
+        """Check if iTerm2 is available (macOS only)."""
+        if sys.platform != "darwin":
+            return False
+        # Check if iTerm2 app exists
+        return Path("/Applications/iTerm.app").exists()
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in iTerm2 using AppleScript."""
+        if not self.is_available():
+            return False
+
+        def escape_applescript(s: str) -> str:
+            """Escape string for AppleScript double-quoted string."""
+            # Escape backslashes first, then double quotes
+            return s.replace("\\", "\\\\").replace('"', '\\"')
+
+        # Build the command to run in the new tab
+        shell_cmd = f'cd "{path}" && {command}' if command else f'cd "{path}"'
+        shell_cmd_escaped = escape_applescript(shell_cmd)
+
+        # Build name setting if provided
+        name_cmd = ""
+        if tab_name:
+            tab_name_escaped = escape_applescript(tab_name)
+            name_cmd = f'\nset name to "{tab_name_escaped}"'
+
+        # AppleScript to open new tab in iTerm2
+        # Handle case where no window exists by creating one
+        applescript = f"""
+            tell application "iTerm2"
+                if (count of windows) = 0 then
+                    create window with default profile
+                end if
+                tell current window
+                    create tab with default profile
+                    tell current session{name_cmd}
+                        write text "{shell_cmd_escaped}"
+                    end tell
+                end tell
+            end tell
+        """
+
+        try:
+            subprocess.run(
+                ["osascript", "-e", applescript],  # noqa: S607
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            return True
+        except subprocess.CalledProcessError:
+            return False

agent_cli/dev/terminals/kitty.py

@@ -0,0 +1,77 @@
+"""Kitty terminal adapter."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from .base import Terminal
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Kitty(Terminal):
+    """Kitty - GPU-accelerated terminal emulator."""
+
+    name = "kitty"
+
+    def detect(self) -> bool:
+        """Detect if running inside Kitty."""
+        # Check KITTY_WINDOW_ID
+        if os.environ.get("KITTY_WINDOW_ID"):
+            return True
+        # Check TERM
+        term = os.environ.get("TERM", "")
+        return "kitty" in term.lower()
+
+    def is_available(self) -> bool:
+        """Check if Kitty is available."""
+        return shutil.which("kitty") is not None
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in Kitty using kitten."""
+        if not self.is_available():
+            return False
+
+        # Check if we're running inside Kitty
+        if not self.detect():
+            # Not in Kitty, open a new window instead
+            cmd = ["kitty", "--directory", str(path)]
+            if tab_name:
+                cmd.extend(["--title", tab_name])
+            if command:
+                cmd.extend(["--", "sh", "-c", command])
+            try:
+                subprocess.Popen(cmd)
+                return True
+            except Exception:
+                return False
+
+        # Use kitten @ to control Kitty from inside
+        cmd = [
+            "kitten",
+            "@",
+            "launch",
+            "--type=tab",
+            f"--cwd={path}",
+        ]
+
+        if tab_name:
+            cmd.append(f"--tab-title={tab_name}")
+
+        if command:
+            cmd.extend(["--", "sh", "-c", command])
+
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False

agent_cli/dev/terminals/registry.py

@@ -0,0 +1,48 @@
+"""Registry for terminal adapters."""
+
+from __future__ import annotations
+
+from agent_cli.dev.registry import Registry
+
+from .apple_terminal import AppleTerminal
+from .base import Terminal  # noqa: TC001
+from .gnome import GnomeTerminal
+from .iterm2 import ITerm2
+from .kitty import Kitty
+from .tmux import Tmux
+from .warp import Warp
+from .zellij import Zellij
+
+# All available terminals (in priority order for detection)
+# Terminal multiplexers first (tmux, zellij) as they run inside other terminals
+_TERMINALS: list[type[Terminal]] = [
+    Tmux,
+    Zellij,
+    ITerm2,
+    Kitty,
+    Warp,
+    AppleTerminal,
+    GnomeTerminal,
+]
+
+_registry: Registry[Terminal] = Registry(_TERMINALS)
+
+
+def get_all_terminals() -> list[Terminal]:
+    """Get instances of all registered terminals."""
+    return _registry.get_all()
+
+
+def get_available_terminals() -> list[Terminal]:
+    """Get all installed/available terminals."""
+    return _registry.get_available()
+
+
+def detect_current_terminal() -> Terminal | None:
+    """Detect which terminal we're running in."""
+    return _registry.detect_current()
+
+
+def get_terminal(name: str) -> Terminal | None:
+    """Get a terminal by name."""
+    return _registry.get_by_name(name)

agent_cli/dev/terminals/tmux.py

@@ -0,0 +1,58 @@
+"""tmux terminal multiplexer adapter."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from typing import TYPE_CHECKING
+
+from .base import Terminal
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Tmux(Terminal):
+    """tmux - Terminal multiplexer."""
+
+    name = "tmux"
+
+    def detect(self) -> bool:
+        """Detect if running inside tmux."""
+        # Check TMUX environment variable
+        return os.environ.get("TMUX") is not None
+
+    def is_available(self) -> bool:
+        """Check if tmux is available."""
+        return shutil.which("tmux") is not None
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new window in tmux.
+
+        Creates a new tmux window (similar to a tab) in the current session.
+        """
+        if not self.is_available():
+            return False
+
+        try:
+            # Create new window in current session
+            # -c sets the working directory, so no need for cd in command
+            cmd = ["tmux", "new-window", "-c", str(path)]
+
+            if tab_name:
+                cmd.extend(["-n", tab_name])
+
+            if command:
+                # Run command in new window (cwd already set by -c)
+                cmd.append(command)
+
+            subprocess.run(cmd, check=True, capture_output=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False

agent_cli/dev/terminals/warp.py

@@ -0,0 +1,132 @@
+"""Warp terminal adapter.
+
+Uses Warp's URI scheme and Launch Configurations for reliable automation.
+Evidence: https://docs.warp.dev/terminal/more-features/uri-scheme
+Evidence: https://docs.warp.dev/terminal/sessions/launch-configurations
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import uuid
+from pathlib import Path
+
+from .base import Terminal, _get_term_program
+
+
+def _get_warp_launch_config_dir() -> Path:
+    """Get the Warp launch configurations directory."""
+    return Path.home() / ".warp" / "launch_configurations"
+
+
+class Warp(Terminal):
+    """Warp - Modern, Rust-based terminal with AI features."""
+
+    name = "warp"
+
+    def detect(self) -> bool:
+        """Detect if running inside Warp."""
+        term_program = _get_term_program()
+        return term_program is not None and "warp" in term_program.lower()
+
+    def is_available(self) -> bool:
+        """Check if Warp is available (macOS only for now)."""
+        if sys.platform != "darwin":
+            return False
+        return Path("/Applications/Warp.app").exists()
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in Warp.
+
+        Uses URI scheme for simple path-only tabs, or Launch Configurations
+        when a command needs to be executed.
+
+        Evidence:
+            URI scheme: https://docs.warp.dev/terminal/more-features/uri-scheme
+            Launch configs: https://docs.warp.dev/terminal/sessions/launch-configurations
+        """
+        if not self.is_available():
+            return False
+
+        # Simple case: no command, just open path via URI scheme
+        # Note: tab_name is ignored here - URI scheme doesn't support tab naming
+        if command is None:
+            try:
+                subprocess.run(
+                    ["open", f"warp://action/new_tab?path={path}"],  # noqa: S607
+                    check=True,
+                    capture_output=True,
+                )
+                return True
+            except subprocess.CalledProcessError:
+                return False
+
+        # Complex case: need to run a command - use Launch Configuration
+        return self._open_with_launch_config(path, command, tab_name)
+
+    def _open_with_launch_config(
+        self,
+        path: Path,
+        command: str,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab using a temporary Launch Configuration.
+
+        Creates a YAML config file, opens it via URI scheme, then cleans up.
+        """
+        config_dir = _get_warp_launch_config_dir()
+        config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create unique config file name
+        config_name = f"agent-cli-{uuid.uuid4().hex[:8]}"
+        config_file = config_dir / f"{config_name}.yaml"
+
+        # Build the YAML config
+        # Quote values that may contain special YAML characters (: # etc.)
+        title = tab_name or "agent-cli"
+        # Escape single quotes by doubling them, then wrap in single quotes
+        escaped_command = command.replace("'", "''")
+        yaml_content = f"""---
+name: {config_name}
+windows:
+  - tabs:
+      - title: '{title}'
+        layout:
+          cwd: '{path.as_posix()}'
+          commands:
+            - exec: '{escaped_command}'
+"""
+
+        try:
+            # Write config file
+            config_file.write_text(yaml_content)
+
+            # Open via URI scheme
+            result = subprocess.run(
+                ["open", f"warp://launch/{config_file}"],  # noqa: S607
+                check=True,
+                capture_output=True,
+            )
+
+            # Clean up after a delay (give Warp time to read the file)
+            # We use a background process to delete after 2 seconds
+            subprocess.Popen(
+                ["sh", "-c", f'sleep 2 && rm -f "{config_file}"'],  # noqa: S607
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+
+            return result.returncode == 0
+        except subprocess.CalledProcessError:
+            # Clean up on failure
+            config_file.unlink(missing_ok=True)
+            return False
+        except Exception:
+            config_file.unlink(missing_ok=True)
+            return False

agent_cli/dev/terminals/zellij.py

@@ -0,0 +1,78 @@
+"""Zellij terminal multiplexer adapter."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import time
+from typing import TYPE_CHECKING
+
+from .base import Terminal
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class Zellij(Terminal):
+    """Zellij - A terminal workspace with batteries included."""
+
+    name = "zellij"
+
+    def detect(self) -> bool:
+        """Detect if running inside Zellij."""
+        # Check ZELLIJ environment variable
+        return os.environ.get("ZELLIJ") is not None
+
+    def is_available(self) -> bool:
+        """Check if Zellij is available."""
+        return shutil.which("zellij") is not None
+
+    def open_new_tab(
+        self,
+        path: Path,
+        command: str | None = None,
+        tab_name: str | None = None,
+    ) -> bool:
+        """Open a new tab in Zellij.
+
+        Creates a new tab in the current Zellij session.
+        """
+        if not self.is_available():
+            return False
+
+        try:
+            # Create new tab using zellij action
+            # Workaround: --cwd requires --layout due to bug (github.com/zellij-org/zellij/issues/2981)
+            cmd = ["zellij", "action", "new-tab", "--layout", "default", "--cwd", str(path)]
+            if tab_name:
+                cmd.extend(["--name", tab_name])
+            subprocess.run(
+                cmd,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            # If command specified, write it to the new pane
+            # --cwd already sets the working directory, so no need for cd
+            if command:
+                # Small delay to ensure the new tab has focus
+                time.sleep(0.1)
+                subprocess.run(
+                    ["zellij", "action", "write-chars", command],  # noqa: S607
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                # Send enter key
+                subprocess.run(
+                    ["zellij", "action", "write", "10"],  # 10 is newline  # noqa: S607
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+
+            return True
+        except subprocess.CalledProcessError:
+            return False