autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/tools/terminal/tools/start_background_process.py

@@ -0,0 +1,104 @@
+"""
+start_background_process tool - Start long-running processes.
+
+Starts processes like servers (yarn dev, uvicorn) in the background
+and returns immediately with a process ID for later reference.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from autobyteus.tools import tool
+from autobyteus.tools.tool_category import ToolCategory
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+
+def _get_background_manager(context: Optional['AgentContext']):
+    """Get or create the background process manager for this agent.
+    
+    Args:
+        context: The agent context.
+        
+    Returns:
+        BackgroundProcessManager instance.
+    """
+    from autobyteus.tools.terminal.background_process_manager import BackgroundProcessManager
+    
+    if context is None:
+        if not hasattr(_get_background_manager, '_default_manager'):
+            _get_background_manager._default_manager = BackgroundProcessManager()
+        return _get_background_manager._default_manager
+    
+    if not hasattr(context, '_background_process_manager'):
+        context._background_process_manager = BackgroundProcessManager()
+    
+    return context._background_process_manager
+
+
+def _get_cwd(context: Optional['AgentContext']) -> str:
+    """Get the working directory for the process.
+    
+    Args:
+        context: The agent context.
+        
+    Returns:
+        Working directory path.
+    """
+    import tempfile
+    
+    if context and hasattr(context, 'workspace') and context.workspace:
+        try:
+            base_path = context.workspace.get_base_path()
+            if base_path and isinstance(base_path, str):
+                return base_path
+        except Exception:
+            pass
+    
+    return tempfile.gettempdir()
+
+
+@tool(name="start_background_process", category=ToolCategory.SYSTEM)
+async def start_background_process(
+    context: Optional['AgentContext'],
+    command: str
+) -> dict:
+    """
+    Start a long-running process in the background.
+
+    Use this for servers, watchers, or any process that doesn't
+    terminate immediately. The process runs independently and
+    you can check its output or stop it later using the returned
+    process_id.
+
+    Args:
+        command: The command to run in background.
+                Examples: "yarn dev", "uvicorn main:app", "npm start"
+
+    Returns:
+        dict with:
+        - process_id: ID to reference this process later
+        - status: "started"
+
+    Examples:
+        - start_background_process("yarn dev")
+        - start_background_process("uvicorn app:main --reload")
+        - start_background_process("python -m http.server 8000")
+    
+    After starting, use:
+        - get_process_output(process_id) to check output
+        - stop_background_process(process_id) to stop it
+    """
+    manager = _get_background_manager(context)
+    cwd = _get_cwd(context)
+    
+    logger.info(f"Starting background process: {command}")
+    process_id = await manager.start_process(command, cwd)
+    
+    return {
+        "process_id": process_id,
+        "status": "started"
+    }

autobyteus/tools/terminal/tools/stop_background_process.py

@@ -0,0 +1,67 @@
+"""
+stop_background_process tool - Stop background processes.
+
+Terminates a background process started with start_background_process.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from autobyteus.tools import tool
+from autobyteus.tools.tool_category import ToolCategory
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+
+def _get_background_manager(context: Optional['AgentContext']):
+    """Get the background process manager for this agent."""
+    from autobyteus.tools.terminal.background_process_manager import BackgroundProcessManager
+    
+    if context is None:
+        if not hasattr(_get_background_manager, '_default_manager'):
+            _get_background_manager._default_manager = BackgroundProcessManager()
+        return _get_background_manager._default_manager
+    
+    if not hasattr(context, '_background_process_manager'):
+        context._background_process_manager = BackgroundProcessManager()
+    
+    return context._background_process_manager
+
+
+@tool(name="stop_background_process", category=ToolCategory.SYSTEM)
+async def stop_background_process(
+    context: Optional['AgentContext'],
+    process_id: str
+) -> dict:
+    """
+    Stop a background process.
+
+    Terminates a process that was started with start_background_process.
+    Sends SIGTERM first for graceful shutdown, then SIGKILL if the
+    process doesn't terminate.
+
+    Args:
+        process_id: ID of the process to stop.
+
+    Returns:
+        dict with:
+        - status: "stopped" if process was found and stopped,
+                  "not_found" if process ID doesn't exist
+        - process_id: The process identifier
+
+    Examples:
+        - Stop a dev server when done testing
+        - Clean up processes before shutting down
+    """
+    manager = _get_background_manager(context)
+    
+    logger.info(f"Stopping background process: {process_id}")
+    success = await manager.stop_process(process_id)
+    
+    return {
+        "status": "stopped" if success else "not_found",
+        "process_id": process_id
+    }

autobyteus/tools/terminal/types.py

@@ -0,0 +1,54 @@
+"""
+Data types for terminal tools.
+
+Contains result types returned by terminal operations.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class TerminalResult:
+    """Result from run_bash.
+    
+    Attributes:
+        stdout: Standard output captured from the command.
+        stderr: Standard error captured from the command (may be mixed with stdout in PTY).
+        exit_code: Exit code if available, None if not captured.
+        timed_out: True if command exceeded timeout.
+    """
+    stdout: str
+    stderr: str
+    exit_code: Optional[int]
+    timed_out: bool
+
+
+@dataclass
+class BackgroundProcessOutput:
+    """Result from get_process_output.
+    
+    Attributes:
+        output: Recent output lines from the process.
+        is_running: True if process is still running.
+        process_id: The process identifier.
+    """
+    output: str
+    is_running: bool
+    process_id: str
+
+
+@dataclass
+class ProcessInfo:
+    """Information about a background process.
+    
+    Attributes:
+        process_id: Unique identifier for the process.
+        command: The command that was executed.
+        started_at: Unix timestamp when process started.
+        is_running: True if process is still running.
+    """
+    process_id: str
+    command: str
+    started_at: float
+    is_running: bool

autobyteus/tools/terminal/wsl_tmux_session.py

@@ -0,0 +1,221 @@
+"""
+WSL + tmux backed terminal session implementation for Windows.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+import subprocess
+from typing import Optional
+
+from autobyteus.tools.terminal.wsl_utils import (
+    ensure_wsl_available,
+    ensure_wsl_distro_available,
+    select_wsl_distro,
+    windows_path_to_wsl,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WslTmuxSession:
+    """Terminal session backed by WSL + tmux (no pywinpty)."""
+
+    def __init__(self, session_id: str):
+        self._session_id = session_id
+        self._closed = False
+        self._wsl_exe: Optional[str] = None
+        self._distro: Optional[str] = None
+        self._session_name: Optional[str] = None
+        self._log_path: Optional[str] = None
+        self._output_offset = 0
+
+    @property
+    def session_id(self) -> str:
+        return self._session_id
+
+    @property
+    def is_alive(self) -> bool:
+        return not self._closed
+
+    async def start(self, cwd: str) -> None:
+        if os.name != "nt":
+            raise RuntimeError("WslTmuxSession is only supported on Windows.")
+        if self._session_name is not None:
+            raise RuntimeError("Session already started.")
+
+        self._wsl_exe = ensure_wsl_available()
+        ensure_wsl_distro_available(self._wsl_exe)
+        self._distro = select_wsl_distro(self._wsl_exe)
+        self._session_name = self._sanitize_session_name(self._session_id)
+
+        await asyncio.to_thread(self._ensure_tmux_available)
+
+        wsl_cwd = windows_path_to_wsl(cwd, wsl_exe=self._wsl_exe)
+        await asyncio.to_thread(
+            self._run_tmux,
+            [
+                "new-session",
+                "-d",
+                "-s",
+                self._session_name,
+                "-c",
+                wsl_cwd,
+                "-x",
+                "120",
+                "-y",
+                "40",
+                "/bin/bash",
+                "--noprofile",
+                "--norc",
+                "-i",
+            ],
+        )
+        await asyncio.to_thread(
+            self._run_tmux,
+            ["send-keys", "-t", self._session_name, "export PS1='$ '", "C-m"],
+        )
+        self._log_path = f"/tmp/autobyteus_tmux_{self._session_name}.log"
+        await asyncio.to_thread(self._reset_log)
+        await asyncio.to_thread(self._start_pipe)
+
+        logger.info(
+            "Started WSL tmux session %s in %s (distro=%s)",
+            self._session_name,
+            wsl_cwd,
+            self._distro,
+        )
+
+    async def write(self, data: bytes) -> None:
+        if self._closed:
+            raise RuntimeError("Session is closed")
+        if self._session_name is None:
+            raise RuntimeError("Session not started")
+
+        text = data.decode("utf-8", errors="replace")
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+
+        parts = text.split("\n")
+        for idx, part in enumerate(parts):
+            if part:
+                await asyncio.to_thread(
+                    self._run_tmux,
+                    ["send-keys", "-t", self._session_name, "-l", part],
+                )
+            if idx < len(parts) - 1:
+                await asyncio.to_thread(
+                    self._run_tmux,
+                    ["send-keys", "-t", self._session_name, "C-m"],
+                )
+
+    async def read(self, timeout: float = 0.1) -> Optional[bytes]:
+        if self._closed or self._session_name is None:
+            return None
+        data = await asyncio.to_thread(self._read_log_delta)
+        if not data:
+            if timeout:
+                await asyncio.sleep(timeout)
+            return None
+        return data
+
+    def resize(self, rows: int, cols: int) -> None:
+        if self._closed or self._session_name is None:
+            return
+        rows = max(1, int(rows))
+        cols = max(1, int(cols))
+        try:
+            self._run_tmux(
+                ["resize-window", "-t", self._session_name, "-x", str(cols), "-y", str(rows)]
+            )
+        except Exception as exc:
+            logger.debug("Failed to resize tmux session %s: %s", self._session_name, exc)
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        if self._session_name:
+            try:
+                await asyncio.to_thread(self._stop_pipe)
+                await asyncio.to_thread(
+                    self._run_tmux, ["kill-session", "-t", self._session_name]
+                )
+            except Exception:
+                pass
+        self._session_name = None
+        self._log_path = None
+        self._output_offset = 0
+        logger.info("Closed WSL tmux session %s", self._session_id)
+
+    def _ensure_tmux_available(self) -> None:
+        try:
+            self._run_wsl_command(["tmux", "-V"], check=True)
+        except RuntimeError as exc:
+            raise RuntimeError(
+                "tmux is required in the WSL distro. Install with `sudo apt install tmux`."
+            ) from exc
+
+    def _run_tmux(self, args: list[str]) -> subprocess.CompletedProcess:
+        return self._run_wsl_command(["tmux", *args], check=True)
+
+    def _reset_log(self) -> None:
+        if not self._log_path:
+            return
+        self._run_wsl_command(["sh", "-c", f"rm -f {self._log_path}; : > {self._log_path}"], check=True)
+        self._output_offset = 0
+
+    def _start_pipe(self) -> None:
+        if not self._log_path:
+            return
+        cmd = f"tmux pipe-pane -o -t {self._session_name}:0.0 'cat >> {self._log_path}'"
+        self._run_wsl_command(["sh", "-c", cmd], check=True)
+
+    def _stop_pipe(self) -> None:
+        if not self._session_name:
+            return
+        self._run_tmux(["pipe-pane", "-t", f"{self._session_name}:0.0"])
+
+    def _read_log_delta(self) -> bytes:
+        if not self._log_path:
+            return b""
+        cmd = (
+            f"if [ -f {self._log_path} ]; then "
+            f"dd if={self._log_path} bs=1 skip={self._output_offset} 2>/dev/null; "
+            f"fi"
+        )
+        result = self._run_wsl_command(["sh", "-c", cmd], check=True)
+        data = result.stdout or b""
+        self._output_offset += len(data)
+        return data
+
+    def _run_wsl_command(self, args: list[str], check: bool) -> subprocess.CompletedProcess:
+        if not self._wsl_exe or not self._distro:
+            raise RuntimeError("WSL session not initialized.")
+        cmd = [self._wsl_exe, "-d", self._distro, "--exec", *args]
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=False,
+            check=False,
+            timeout=10,
+        )
+        if check and result.returncode != 0:
+            stderr = self._decode_output(result.stderr)
+            raise RuntimeError(stderr or "WSL command failed")
+        return result
+
+    @staticmethod
+    def _decode_output(raw: bytes) -> str:
+        if not raw:
+            return ""
+        if b"\x00" in raw:
+            return raw.decode("utf-16-le", errors="replace")
+        return raw.decode("utf-8", errors="replace")
+
+    @staticmethod
+    def _sanitize_session_name(session_id: str) -> str:
+        base = re.sub(r"[^a-zA-Z0-9_-]", "_", session_id)
+        return f"autobyteus_{base}"

autobyteus/tools/terminal/wsl_utils.py

@@ -0,0 +1,156 @@
+"""
+WSL utilities for Windows terminal backend.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import shutil
+import subprocess
+from typing import List, Optional
+
+
+_WSL_MISSING_MESSAGE = (
+    "WSL is not available. Install it with `wsl --install` and reboot, "
+    "then ensure a Linux distro is installed."
+)
+
+
+def find_wsl_executable() -> Optional[str]:
+    """Return the path to wsl.exe (preferred) or wsl if available."""
+    return shutil.which("wsl.exe") or shutil.which("wsl")
+
+
+def _decode_wsl_bytes(raw: bytes) -> str:
+    """Decode WSL output that may be UTF-16LE on Windows consoles."""
+    if not raw:
+        return ""
+    if b"\x00" in raw:
+        return raw.decode("utf-16-le", errors="replace")
+    return raw.decode("utf-8", errors="replace")
+
+
+def ensure_wsl_available() -> str:
+    """Return the WSL executable path or raise with guidance."""
+    wsl_exe = find_wsl_executable()
+    if not wsl_exe:
+        raise RuntimeError(_WSL_MISSING_MESSAGE)
+    return wsl_exe
+
+
+def list_wsl_distros(wsl_exe: str) -> List[str]:
+    """Return a list of installed WSL distro names."""
+    result = subprocess.run(
+        [wsl_exe, "-l", "-q"],
+        capture_output=True,
+        text=False,
+        check=False,
+        timeout=5,
+    )
+    if result.returncode != 0:
+        return []
+    output = _decode_wsl_bytes(result.stdout)
+    return [line.strip() for line in output.splitlines() if line.strip()]
+
+
+def get_default_wsl_distro(wsl_exe: str) -> Optional[str]:
+    """Return the default WSL distro name if available."""
+    result = subprocess.run(
+        [wsl_exe, "-l", "-v"],
+        capture_output=True,
+        text=False,
+        check=False,
+        timeout=5,
+    )
+    if result.returncode != 0:
+        return None
+    output = _decode_wsl_bytes(result.stdout)
+    for line in output.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("*"):
+            parts = stripped.split()
+            if len(parts) >= 2:
+                return parts[1]
+    return None
+
+
+def select_wsl_distro(wsl_exe: str) -> str:
+    """Select a usable WSL distro, preferring non-Docker defaults."""
+    distros = list_wsl_distros(wsl_exe)
+    if not distros:
+        raise RuntimeError(
+            "No WSL distro is installed. Run `wsl --install` "
+            "or install a distro from the Microsoft Store."
+        )
+
+    default = get_default_wsl_distro(wsl_exe)
+    excluded = {"docker-desktop", "docker-desktop-data"}
+
+    if default and default not in excluded:
+        return default
+
+    for distro in distros:
+        if distro and distro not in excluded:
+            return distro
+
+    return default or distros[0]
+
+
+def ensure_wsl_distro_available(wsl_exe: str) -> None:
+    """Raise if no WSL distro is installed."""
+    distros = list_wsl_distros(wsl_exe)
+    if not distros:
+        raise RuntimeError(
+            "No WSL distro is installed. Run `wsl --install` "
+            "or install a distro from the Microsoft Store."
+        )
+
+
+def _run_wslpath(wsl_exe: str, path: str) -> Optional[str]:
+    """Try to convert a Windows path to WSL path via wslpath."""
+    result = subprocess.run(
+        [wsl_exe, "wslpath", "-a", "-u", path],
+        capture_output=True,
+        text=False,
+        check=False,
+        timeout=5,
+    )
+    if result.returncode != 0:
+        return None
+    output = _decode_wsl_bytes(result.stdout).strip()
+    return output or None
+
+
+def _manual_windows_path_to_wsl(path: str) -> str:
+    """Manual conversion for Windows drive paths to /mnt/<drive>/..."""
+    windows_path = pathlib.PureWindowsPath(path)
+
+    if windows_path.drive:
+        drive_letter = windows_path.drive.rstrip(":").lower()
+        parts = windows_path.parts[1:]  # strip drive
+        if parts:
+            return f"/mnt/{drive_letter}/" + "/".join(parts)
+        return f"/mnt/{drive_letter}"
+
+    raise ValueError(f"Unsupported Windows path format: {path}")
+
+
+def windows_path_to_wsl(path: str, wsl_exe: Optional[str] = None) -> str:
+    """Convert a Windows path to a WSL path, with wslpath fallback."""
+    if not path:
+        raise ValueError("Path must be a non-empty string.")
+
+    if path.startswith("/"):
+        return path
+
+    if path.startswith("\\\\"):
+        raise ValueError("UNC paths are not supported for WSL conversion.")
+
+    if wsl_exe is None:
+        wsl_exe = ensure_wsl_available()
+
+    wslpath = _run_wslpath(wsl_exe, path)
+    if wslpath:
+        return wslpath
+
+    return _manual_windows_path_to_wsl(path)

autobyteus/tools/tool_meta.py

@@ -35,26 +35,8 @@ class ToolMeta(ABCMeta):
                  logger.error(f"Tool class {name} ({tool_name}) must return a valid string from get_description(). Skipping registration.")
                  return
 
-            argument_schema: ParameterSchema = None 
-            try:
-                argument_schema = cls.get_argument_schema() 
-                if argument_schema is not None and not isinstance(argument_schema, ParameterSchema): 
-                    logger.error(f"Tool class {name} ({tool_name}) get_argument_schema() must return a ParameterSchema or None. Got {type(argument_schema)}. Skipping registration.")
-                    return
-            except Exception as e:
-                logger.error(f"Tool class {name} ({tool_name}) failed to provide argument_schema via get_argument_schema(): {e}. Skipping registration.", exc_info=True)
-                return
+            # Note: We do not call the schema methods here. We pass them as providers.
             
-            instantiation_config_schema: ParameterSchema = None 
-            if hasattr(cls, 'get_config_schema'):
-                try:
-                    instantiation_config_schema = cls.get_config_schema()
-                    if instantiation_config_schema is not None and not isinstance(instantiation_config_schema, ParameterSchema): 
-                        logger.warning(f"Tool class {name} ({tool_name}) get_config_schema() returned non-ParameterSchema type: {type(instantiation_config_schema)}. Treating as no config schema.")
-                        instantiation_config_schema = None
-                except Exception as e:
-                    logger.warning(f"Tool class {name} ({tool_name}) has get_config_schema() but it failed: {e}. Assuming no instantiation config.")
-
             # Get category from class attribute, defaulting to "General"
             category_str = getattr(cls, 'CATEGORY', ToolCategory.GENERAL)
             
@@ -64,16 +46,14 @@ class ToolMeta(ABCMeta):
                 description=general_description, 
                 tool_class=cls,
                 custom_factory=None,
-                argument_schema=argument_schema,
-                config_schema=instantiation_config_schema,
+                argument_schema_provider=cls.get_argument_schema,
+                config_schema_provider=cls.get_config_schema,
                 origin=ToolOrigin.LOCAL,
                 category=category_str
             )
             default_tool_registry.register_tool(definition)
             
-            arg_schema_info = f"args: {len(argument_schema) if argument_schema else '0'}"
-            config_info = f"inst_config: {len(instantiation_config_schema) if instantiation_config_schema else '0'}"
-            logger.info(f"Auto-registered tool: '{tool_name}' from class {name} ({arg_schema_info}, {config_info})")
+            logger.info(f"Auto-registered tool: '{tool_name}' from class {name}")
 
         except AttributeError as e:
              logger.error(f"Tool class {name} is missing a required method ({e}). Skipping registration.")