auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/shell_commands/timeout_config.py

@@ -0,0 +1,315 @@
+"""
+Timeout configuration module for shell command execution.
+
+This module provides flexible timeout configuration for different types of commands
+and execution scenarios.
+"""
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Union, List
+
+from .exceptions import TimeoutConfigError
+
+
+@dataclass
+class TimeoutConfig:
+    """
+    Configuration class for command timeout settings.
+    
+    This class provides comprehensive timeout configuration including:
+    - Default timeout for all commands
+    - Interactive command timeout
+    - Process cleanup timeout
+    - Grace period for graceful termination
+    - Command-specific timeout overrides
+    
+    Attributes:
+        default_timeout: Default timeout for all commands (seconds)
+        interactive_timeout: Timeout for interactive commands (seconds)
+        cleanup_timeout: Timeout for process cleanup operations (seconds)
+        grace_period: Grace period for graceful process termination (seconds)
+        command_timeouts: Dictionary mapping command patterns to specific timeouts
+    """
+    
+    default_timeout: Optional[float] = 300.0  # 5 minutes
+    interactive_timeout: Optional[float] = 600.0  # 10 minutes
+    cleanup_timeout: float = 10.0  # 10 seconds
+    grace_period: float = 5.0  # 5 seconds
+    
+    # Command-specific timeout overrides
+    command_timeouts: Dict[str, float] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        self._validate_config()
+    
+    def _validate_config(self):
+        """Validate timeout configuration values."""
+        
+        # Validate default_timeout
+        if self.default_timeout is not None and self.default_timeout <= 0:
+            raise TimeoutConfigError(
+                "default_timeout", 
+                self.default_timeout, 
+                "must be positive or None"
+            )
+        
+        # Validate interactive_timeout
+        if self.interactive_timeout is not None and self.interactive_timeout <= 0:
+            raise TimeoutConfigError(
+                "interactive_timeout", 
+                self.interactive_timeout, 
+                "must be positive or None"
+            )
+        
+        # Validate cleanup_timeout
+        if self.cleanup_timeout <= 0:
+            raise TimeoutConfigError(
+                "cleanup_timeout", 
+                self.cleanup_timeout, 
+                "must be positive"
+            )
+        
+        # Validate grace_period
+        if self.grace_period <= 0:
+            raise TimeoutConfigError(
+                "grace_period", 
+                self.grace_period, 
+                "must be positive"
+            )
+        
+        # Validate command_timeouts
+        for command, timeout in self.command_timeouts.items():
+            if timeout <= 0:
+                raise TimeoutConfigError(
+                    f"command_timeouts[{command}]", 
+                    timeout, 
+                    "must be positive"
+                )
+    
+    def get_timeout_for_command(self, command: Union[str, List[str]]) -> Optional[float]:
+        """
+        Get the appropriate timeout for a specific command.
+        
+        This method checks for command-specific timeouts first, then falls back
+        to the default timeout.
+        
+        Args:
+            command: The command string or list to get timeout for
+            
+        Returns:
+            Timeout in seconds, or None for no timeout
+        """
+        # Convert command to string if needed
+        if isinstance(command, list):
+            if not command:
+                return self.default_timeout
+            command_str = " ".join(str(arg) for arg in command)
+        else:
+            command_str = command
+            
+        if not command_str:
+            return self.default_timeout
+        
+        # Extract the base command (first word)
+        base_command = command_str.strip().split()[0] if command_str.strip() else ""
+        command_parts = command_str.strip().split()
+        is_single_command = len(command_parts) == 1
+        
+        # Check for pattern matches - prioritize patterns that match from the beginning
+        # Sort patterns by specificity: exact matches first for single commands, then patterns, then exact for multi-word
+        def pattern_priority(item):
+            pattern, _ = item
+            # For single-word commands, exact matches get highest priority
+            # For multi-word commands, patterns get higher priority than base command exact matches
+            is_exact = pattern == base_command
+            is_pattern = '*' in pattern
+            # Patterns starting with text (not *) get higher priority than wildcards
+            starts_with_text = not pattern.startswith('*')
+            # Longer patterns get higher priority within same category
+            length = len(pattern)
+            
+            if is_single_command:
+                # Single command: exact > patterns
+                return (is_exact, not is_pattern, starts_with_text, length)
+            else:
+                # Multi-word command: patterns > exact base command
+                return (not is_exact or is_pattern, starts_with_text, length)
+        
+        patterns = sorted(self.command_timeouts.items(), key=pattern_priority, reverse=True)
+        
+        for pattern, timeout in patterns:
+            # For exact matches, check base command
+            if pattern == base_command and ('*' not in pattern):
+                # For multi-word commands, only return exact match if no patterns match
+                if is_single_command:
+                    return timeout
+                # For multi-word, continue to check patterns first
+            # For patterns, check full command string
+            if self._matches_pattern(command_str, pattern):
+                return timeout
+        
+        # If we get here and it's a multi-word command, check for exact base command match
+        if not is_single_command and base_command in self.command_timeouts:
+            pattern = base_command
+            if '*' not in pattern:  # Make sure it's not a pattern
+                return self.command_timeouts[base_command]
+        
+        # Fall back to default timeout
+        return self.default_timeout
+    
+    def _matches_pattern(self, command: str, pattern: str) -> bool:
+        """
+        Check if a command matches a timeout pattern.
+        
+        Args:
+            command: The command to check
+            pattern: The pattern to match against
+            
+        Returns:
+            True if the command matches the pattern
+        """
+        # Support simple wildcard patterns
+        if '*' in pattern:
+            # Convert simple wildcard to regex
+            regex_pattern = pattern.replace('*', '.*')
+            return bool(re.match(regex_pattern, command))
+        
+        # Support exact substring matching
+        return pattern in command
+    
+    def set_command_timeout(self, command_pattern: str, timeout: float):
+        """
+        Set timeout for a specific command pattern.
+        
+        Args:
+            command_pattern: Command or pattern to set timeout for
+            timeout: Timeout value in seconds
+            
+        Raises:
+            TimeoutConfigError: If timeout value is invalid
+        """
+        if timeout <= 0:
+            raise TimeoutConfigError(
+                f"command_timeouts[{command_pattern}]", 
+                timeout, 
+                "must be positive"
+            )
+        
+        self.command_timeouts[command_pattern] = timeout
+    
+    def remove_command_timeout(self, command_pattern: str):
+        """
+        Remove timeout override for a command pattern.
+        
+        Args:
+            command_pattern: Command pattern to remove
+        """
+        self.command_timeouts.pop(command_pattern, None)
+    
+    @classmethod
+    def from_env(cls) -> 'TimeoutConfig':
+        """
+        Create TimeoutConfig from environment variables.
+        
+        Environment variables:
+            AUTOCODER_DEFAULT_TIMEOUT: Default timeout in seconds
+            AUTOCODER_INTERACTIVE_TIMEOUT: Interactive timeout in seconds
+            AUTOCODER_CLEANUP_TIMEOUT: Cleanup timeout in seconds
+            AUTOCODER_GRACE_PERIOD: Grace period in seconds
+            
+        Returns:
+            TimeoutConfig instance configured from environment
+        """
+        def get_optional_float(env_var: str, default: Optional[float]) -> Optional[float]:
+            value = os.getenv(env_var)
+            if value is None:
+                return default
+            if value.lower() in ('none', 'null', ''):
+                return None
+            try:
+                return float(value)
+            except ValueError:
+                raise TimeoutConfigError(
+                    env_var, 
+                    value, 
+                    "must be a valid number or 'none'"
+                )
+        
+        def get_float(env_var: str, default: float) -> float:
+            value = os.getenv(env_var)
+            if value is None:
+                return default
+            try:
+                return float(value)
+            except ValueError:
+                raise TimeoutConfigError(
+                    env_var, 
+                    value, 
+                    "must be a valid number"
+                )
+        
+        return cls(
+            default_timeout=get_optional_float('AUTOCODER_DEFAULT_TIMEOUT', 300.0),
+            interactive_timeout=get_optional_float('AUTOCODER_INTERACTIVE_TIMEOUT', 600.0),
+            cleanup_timeout=get_float('AUTOCODER_CLEANUP_TIMEOUT', 10.0),
+            grace_period=get_float('AUTOCODER_GRACE_PERIOD', 5.0),
+        )
+    
+    def to_dict(self) -> Dict:
+        """
+        Convert configuration to dictionary.
+        
+        Returns:
+            Dictionary representation of the configuration
+        """
+        return {
+            'default_timeout': self.default_timeout,
+            'interactive_timeout': self.interactive_timeout,
+            'cleanup_timeout': self.cleanup_timeout,
+            'grace_period': self.grace_period,
+            'command_timeouts': self.command_timeouts.copy(),
+        }
+    
+    @classmethod
+    def from_dict(cls, config_dict: Dict) -> 'TimeoutConfig':
+        """
+        Create TimeoutConfig from dictionary.
+        
+        Args:
+            config_dict: Dictionary containing configuration values
+            
+        Returns:
+            TimeoutConfig instance
+        """
+        return cls(
+            default_timeout=config_dict.get('default_timeout', 300.0),
+            interactive_timeout=config_dict.get('interactive_timeout', 600.0),
+            cleanup_timeout=config_dict.get('cleanup_timeout', 10.0),
+            grace_period=config_dict.get('grace_period', 5.0),
+            command_timeouts=config_dict.get('command_timeouts', {}),
+        )
+    
+    def __str__(self) -> str:
+        """String representation of the configuration."""
+        return (
+            f"TimeoutConfig("
+            f"default={self.default_timeout}, "
+            f"interactive={self.interactive_timeout}, "
+            f"cleanup={self.cleanup_timeout}, "
+            f"grace={self.grace_period}, "
+            f"overrides={len(self.command_timeouts)})"
+        )
+    
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return (
+            f"TimeoutConfig("
+            f"default_timeout={self.default_timeout}, "
+            f"interactive_timeout={self.interactive_timeout}, "
+            f"cleanup_timeout={self.cleanup_timeout}, "
+            f"grace_period={self.grace_period}, "
+            f"command_timeouts={self.command_timeouts})"
+        ) 

autocoder/common/shell_commands/timeout_manager.py

@@ -0,0 +1,352 @@
+"""
+Timeout manager module for shell command execution.
+
+This module provides timeout management functionality including:
+- Starting and canceling timeouts
+- Handling timeout events
+- Managing multiple concurrent timeouts
+- Integration with process cleanup
+"""
+
+import subprocess
+import threading
+import time
+from typing import Dict, Optional, Callable
+from loguru import logger
+
+from .timeout_config import TimeoutConfig
+from .process_cleanup import cleanup_process_tree
+from .exceptions import CommandTimeoutError
+
+
+class TimeoutManager:
+    """
+    Manager for command execution timeouts.
+    
+    This class handles timeout management for command execution, including
+    starting timers, canceling them, and handling timeout events with
+    proper process cleanup.
+    
+    Attributes:
+        config: Timeout configuration
+        active_timers: Dictionary of active timeout timers
+        timeout_callbacks: Dictionary of timeout callbacks
+    """
+    
+    def __init__(self, config: TimeoutConfig):
+        """
+        Initialize timeout manager.
+        
+        Args:
+            config: Timeout configuration to use
+        """
+        self.config = config
+        self.active_timers: Dict[int, threading.Timer] = {}
+        self.timeout_callbacks: Dict[int, Callable] = {}
+        self._lock = threading.Lock()
+        
+        logger.debug(f"TimeoutManager initialized with config: {config}")
+    
+    def start_timeout(
+        self, 
+        process: subprocess.Popen, 
+        timeout: float,
+        callback: Optional[Callable] = None
+    ) -> None:
+        """
+        Start a timeout for a process.
+        
+        Args:
+            process: The subprocess.Popen object to monitor
+            timeout: Timeout duration in seconds
+            callback: Optional callback to call on timeout (in addition to cleanup)
+        """
+        if timeout <= 0:
+            logger.warning(f"Invalid timeout value: {timeout}, ignoring")
+            return
+        
+        pid = process.pid
+        
+        with self._lock:
+            # Cancel any existing timeout for this process (without acquiring lock again)
+            existing_timer = self.active_timers.pop(pid, None)
+            existing_callback = self.timeout_callbacks.pop(pid, None)
+            
+            if existing_timer:
+                existing_timer.cancel()
+                logger.debug(f"Canceled existing timeout for PID {pid}")
+            
+            # Create timeout handler
+            def timeout_handler():
+                self._handle_timeout(process, timeout, callback)
+            
+            # Start timer
+            timer = threading.Timer(timeout, timeout_handler)
+            timer.daemon = True  # Don't prevent program exit
+            
+            try:
+                timer.start()
+                
+                # Store timer and callback only if start was successful
+                self.active_timers[pid] = timer
+                if callback:
+                    self.timeout_callbacks[pid] = callback
+                
+                logger.debug(f"Started timeout for PID {pid} with {timeout}s timeout")
+                
+            except Exception as e:
+                logger.error(f"Failed to start timeout for PID {pid}: {e}")
+                # Don't store the timer since it failed to start
+    
+    def cancel_timeout(self, process: subprocess.Popen) -> bool:
+        """
+        Cancel timeout for a process.
+        
+        Args:
+            process: The subprocess.Popen object
+            
+        Returns:
+            True if timeout was canceled, False if no timeout was active
+        """
+        pid = process.pid
+        
+        with self._lock:
+            timer = self.active_timers.pop(pid, None)
+            callback = self.timeout_callbacks.pop(pid, None)
+            
+            if timer:
+                timer.cancel()
+                logger.debug(f"Canceled timeout for PID {pid}")
+                return True
+            
+            return False
+    
+    def is_timeout_active(self, process: subprocess.Popen) -> bool:
+        """
+        Check if timeout is active for a process.
+        
+        Args:
+            process: The subprocess.Popen object
+            
+        Returns:
+            True if timeout is active
+        """
+        pid = process.pid
+        with self._lock:
+            return pid in self.active_timers
+    
+    def get_remaining_timeout(self, process: subprocess.Popen) -> Optional[float]:
+        """
+        Get remaining timeout for a process.
+        
+        Args:
+            process: The subprocess.Popen object
+            
+        Returns:
+            Remaining timeout in seconds, or None if no timeout active
+        """
+        pid = process.pid
+        with self._lock:
+            timer = self.active_timers.get(pid)
+            if timer and timer.is_alive():
+                # This is an approximation since Timer doesn't expose remaining time
+                # In practice, this would need more sophisticated tracking
+                return None  # Could implement if needed
+            return None
+    
+    def _handle_timeout(
+        self, 
+        process: subprocess.Popen, 
+        timeout: float,
+        callback: Optional[Callable] = None
+    ) -> None:
+        """
+        Handle timeout event for a process.
+        
+        Args:
+            process: The subprocess.Popen object that timed out
+            timeout: The timeout value that was exceeded
+            callback: Optional user callback to execute
+        """
+        pid = process.pid
+        
+        logger.warning(f"Process {pid} timed out after {timeout} seconds")
+        
+        try:
+            # Remove from active timers
+            with self._lock:
+                self.active_timers.pop(pid, None)
+                self.timeout_callbacks.pop(pid, None)
+            
+            # Execute user callback if provided
+            if callback:
+                try:
+                    callback(process, timeout)
+                except Exception as e:
+                    logger.error(f"Error in timeout callback for PID {pid}: {e}")
+            
+            # Attempt to cleanup the process tree
+            try:
+                cleanup_success = cleanup_process_tree(
+                    pid, 
+                    timeout=self.config.grace_period,
+                    force_timeout=self.config.cleanup_timeout - self.config.grace_period
+                )
+                
+                if cleanup_success:
+                    logger.debug(f"Successfully cleaned up process tree for PID {pid}")
+                else:
+                    logger.warning(f"Failed to fully cleanup process tree for PID {pid}")
+                    
+            except Exception as e:
+                logger.error(f"Error during process cleanup for PID {pid}: {e}")
+        
+        except Exception as e:
+            logger.error(f"Error handling timeout for PID {pid}: {e}")
+    
+    def cleanup_all_timeouts(self) -> None:
+        """
+        Cancel all active timeouts.
+        
+        This method should be called when shutting down to ensure
+        all timers are properly canceled.
+        """
+        with self._lock:
+            for pid, timer in self.active_timers.items():
+                try:
+                    timer.cancel()
+                    logger.debug(f"Canceled timeout for PID {pid} during cleanup")
+                except Exception as e:
+                    logger.error(f"Error canceling timeout for PID {pid}: {e}")
+            
+            self.active_timers.clear()
+            self.timeout_callbacks.clear()
+            
+        logger.debug("All timeouts cleaned up")
+    
+    def get_active_timeouts(self) -> Dict[int, bool]:
+        """
+        Get information about active timeouts.
+        
+        Returns:
+            Dictionary mapping PID to timer status (alive/dead)
+        """
+        with self._lock:
+            return {
+                pid: timer.is_alive() 
+                for pid, timer in self.active_timers.items()
+            }
+    
+    def __del__(self):
+        """Cleanup when manager is destroyed."""
+        try:
+            self.cleanup_all_timeouts()
+        except Exception:
+            pass  # Ignore errors during cleanup
+
+
+class TimeoutContext:
+    """
+    Context manager for timeout management.
+    
+    This provides a convenient way to manage timeouts using the 'with' statement.
+    The timeout is automatically canceled when exiting the context.
+    """
+    
+    def __init__(
+        self, 
+        manager: TimeoutManager, 
+        process: subprocess.Popen, 
+        timeout: float,
+        callback: Optional[Callable] = None
+    ):
+        """
+        Initialize timeout context.
+        
+        Args:
+            manager: TimeoutManager instance
+            process: Process to monitor
+            timeout: Timeout duration
+            callback: Optional timeout callback
+        """
+        self.manager = manager
+        self.process = process
+        self.timeout = timeout
+        self.callback = callback
+    
+    def __enter__(self) -> 'TimeoutContext':
+        """Start timeout when entering context."""
+        self.manager.start_timeout(self.process, self.timeout, self.callback)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Cancel timeout when exiting context."""
+        self.manager.cancel_timeout(self.process)
+
+
+class GlobalTimeoutManager:
+    """
+    Global singleton timeout manager.
+    
+    This provides a convenient way to access a global timeout manager
+    throughout the application.
+    """
+    
+    _instance: Optional[TimeoutManager] = None
+    _lock = threading.Lock()
+    
+    @classmethod
+    def get_instance(cls, config: Optional[TimeoutConfig] = None) -> TimeoutManager:
+        """
+        Get or create the global timeout manager instance.
+        
+        Args:
+            config: Optional config to use for first initialization
+            
+        Returns:
+            Global TimeoutManager instance
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    if config is None:
+                        config = TimeoutConfig()
+                    cls._instance = TimeoutManager(config)
+                    logger.debug("Created global TimeoutManager instance")
+        
+        return cls._instance
+    
+    @classmethod
+    def reset_instance(cls) -> None:
+        """
+        Reset the global instance.
+        
+        This is mainly useful for testing.
+        """
+        with cls._lock:
+            if cls._instance:
+                cls._instance.cleanup_all_timeouts()
+            cls._instance = None
+            logger.debug("Reset global TimeoutManager instance")
+
+
+def create_timeout_context(
+    process: subprocess.Popen, 
+    timeout: float,
+    config: Optional[TimeoutConfig] = None,
+    callback: Optional[Callable] = None
+) -> TimeoutContext:
+    """
+    Convenience function to create a timeout context.
+    
+    Args:
+        process: Process to monitor
+        timeout: Timeout duration
+        config: Optional timeout configuration
+        callback: Optional timeout callback
+        
+    Returns:
+        TimeoutContext instance
+    """
+    manager = GlobalTimeoutManager.get_instance(config)
+    return TimeoutContext(manager, process, timeout, callback) 

autocoder/common/terminal_paste/__init__.py

@@ -0,0 +1,14 @@
+"""Terminal paste handling module for auto-coder.
+
+This module provides functionality to intercept terminal paste events,
+save pasted content to files, and resolve placeholders in user input.
+"""
+
+from .paste_handler import register_paste_handler, resolve_paste_placeholders
+from .paste_manager import PasteManager
+
+__all__ = [
+    "register_paste_handler",
+    "resolve_paste_placeholders", 
+    "PasteManager"
+]