regcode 0.1.0__py3-none-any.whl

regcode/monty_sandbox.py

@@ -0,0 +1,415 @@
+"""Sandbox for secure, isolated code execution using pydantic-monty.
+
+Provides Monty-based code execution with:
+- Rust-based secure Python interpreter
+- Resource limits (memory, CPU, recursion)
+- External function registration
+- Type checking
+- Stream collection
+- File system sandboxing
+
+Designed as a drop-in replacement for the subprocess-based Sandbox class.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import tempfile
+import textwrap
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable
+
+from pydantic_monty import (
+    CollectString,
+    Monty,
+    MontyRuntimeError,
+    MontySyntaxError,
+    MontyTypingError,
+    ResourceLimits,
+)
+
+
+@dataclass
+class MontySandboxConfig:
+    """Configuration for the Monty sandbox."""
+
+    # Resource limits
+    max_duration_secs: float = 10.0
+    max_memory_mb: int = 64
+    max_recursion_depth: int = 100
+    max_allocations: int = 10000
+
+    # Type checking
+    type_check: bool = True
+
+    # Working directory
+    sandbox_dir: Path | None = None
+
+    # Max output size
+    max_output_bytes: int = 65536
+
+    # Allowed imports (whitelist)
+    allowed_imports: list[str] = field(default_factory=lambda: [
+        "os", "sys", "json", "re", "math", "datetime",
+        "collections", "itertools", "functools", "pathlib",
+        "subprocess", "asyncio", "http", "urllib", "csv",
+        "io", "string", "textwrap", "copy", "pprint",
+        "time", "random", "uuid", "hashlib", "base64",
+    ])
+
+
+class MontySandboxError(Exception):
+    """Raised when Monty sandbox execution fails."""
+
+    def __init__(
+        self,
+        message: str,
+        stdout: str = "",
+        stderr: str = "",
+        exit_code: int = -1,
+    ):
+        super().__init__(message)
+        self.stdout = stdout
+        self.stderr = stderr
+        self.exit_code = exit_code
+
+
+@dataclass
+class MontySandboxResult:
+    """Result from a Monty sandboxed execution."""
+
+    stdout: str
+    stderr: str
+    exit_code: int
+    execution_time: float
+    result: Any = None
+
+    @property
+    def success(self) -> bool:
+        return self.exit_code == 0 and not self.stdout.startswith("SANDBOX_ERROR")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "exit_code": self.exit_code,
+            "execution_time": round(self.execution_time, 3),
+            "result": self.result,
+            "success": self.success,
+        }
+
+
+class MontySandbox:
+    """Monty-based execution sandbox for secure Python code.
+
+    Provides isolation using pydantic-monty:
+    - Rust-based secure Python interpreter
+    - Resource limits (memory, CPU, recursion)
+    - External function registration
+    - Type checking
+    - Stream collection
+
+    Architecture note: Uses pydantic-monty for secure code execution.
+    Provides a drop-in replacement for the existing Sandbox class.
+    """
+
+    def __init__(self, config: MontySandboxConfig | None = None):
+        self.config = config or MontySandboxConfig()
+        self._sandbox_root: Path | None = None
+        self._external_functions: dict[str, Callable] = {}
+
+    @property
+    def sandbox_root(self) -> Path:
+        """Get or create the sandbox working directory."""
+        if self._sandbox_root is None:
+            base = self.config.sandbox_dir or Path(
+                tempfile.mkdtemp(prefix="regcode_monty_")
+            )
+            self._sandbox_root = base / f"session_{int(time.time())}"
+            self._sandbox_root.mkdir(parents=True, exist_ok=True)
+        return self._sandbox_root
+
+    def register_function(self, name: str, func: Callable) -> None:
+        """Register an external function for use in Monty code."""
+        self._external_functions[name] = func
+
+    def register_functions(self, functions: dict[str, Callable]) -> None:
+        """Register multiple external functions."""
+        self._external_functions.update(functions)
+
+    def clear_functions(self) -> None:
+        """Clear all registered external functions."""
+        self._external_functions.clear()
+
+    def cleanup(self) -> None:
+        """Clean up sandbox resources."""
+        if self._sandbox_root and self._sandbox_root.exists():
+            shutil.rmtree(self._sandbox_root, ignore_errors=True)
+        self._sandbox_root = None
+        self._external_functions.clear()
+
+    def __del__(self) -> None:
+        self.cleanup()
+
+    def _get_event_loop(self):
+        """Get/create event loop, handling running and non-running contexts."""
+        try:
+            loop = asyncio.get_running_loop()
+            # A loop is already running (e.g., from pytest)
+            return loop, False
+        except RuntimeError:
+            # No loop running - create a new one
+            loop = asyncio.new_event_loop()
+            return loop, True
+
+    def run(
+        self,
+        code: str,
+        timeout: float | None = None,
+        external_functions: dict[str, Callable] | None = None,
+    ) -> MontySandboxResult:
+        """Execute Python code in the Monty sandbox.
+
+        Args:
+            code: Python code string to execute.
+            timeout: Override timeout for this execution.
+            external_functions: External functions to register for this execution.
+
+        Returns:
+            MontySandboxResult with stdout, stderr, exit_code, result.
+        """
+        timeout = timeout or self.config.max_duration_secs
+
+        # Merge external functions
+        funcs = self._external_functions.copy()
+        if external_functions:
+            funcs.update(external_functions)
+
+        # Set up resource limits
+        limits = ResourceLimits(
+            max_duration_secs=timeout,
+            max_memory=self.config.max_memory_mb * 1024 * 1024,
+            max_recursion_depth=self.config.max_recursion_depth,
+            max_allocations=self.config.max_allocations,
+        )
+
+        try:
+            # Create Monty runner
+            monty = Monty(code)
+
+            # Execute code - always use asyncio.run() for full isolation
+            # This avoids "no running event loop" errors that occur when
+            # the Monty library checks for a running loop at the process level
+            # Create callback outside async scope so we can access .output
+            cb = CollectString()
+
+            try:
+                async def _async_run():
+                    return await monty.run_async(
+                        external_functions=funcs,
+                        limits=limits,
+                        print_callback=cb,
+                    )
+
+                result = asyncio.run(_async_run())
+            except Exception as e:
+                return MontySandboxResult(
+                    stdout=f"SANDBOX_ERROR: {str(e)}",
+                    stderr="",
+                    exit_code=1,
+                    execution_time=0,
+                    result=None,
+                )
+
+            # Extract stdout from callback, result is the last expression value
+            stdout = cb.output or ""
+            actual_result = result
+
+            return MontySandboxResult(
+                stdout=stdout[: self.config.max_output_bytes] if stdout else "",
+                stderr="",
+                exit_code=0,
+                execution_time=timeout,
+                result=actual_result,
+            )
+
+        except (MontyRuntimeError, MontySyntaxError, MontyTypingError) as e:
+            return MontySandboxResult(
+                stdout=f"SANDBOX_ERROR: {str(e)}",
+                stderr="",
+                exit_code=1,
+                execution_time=0,
+                result=None,
+            )
+        except Exception as e:
+            return MontySandboxResult(
+                stdout=f"SANDBOX_ERROR: {str(e)}",
+                stderr="",
+                exit_code=1,
+                execution_time=0,
+                result=None,
+            )
+
+    def run_python(
+        self,
+        code: str,
+        timeout: float | None = None,
+        stdin: str | None = None,
+    ) -> MontySandboxResult:
+        """Execute Python code in the Monty sandbox.
+
+        Args:
+            code: Python code string to execute.
+            timeout: Override timeout.
+            stdin: Optional stdin (not used in Monty, kept for compatibility).
+
+        Returns:
+            MontySandboxResult.
+        """
+        return self.run(code, timeout=timeout)
+
+    def run_shell(
+        self,
+        command: str,
+        timeout: float | None = None,
+    ) -> MontySandboxResult:
+        """Execute a shell command in the Monty sandbox.
+
+        Args:
+            command: Shell command string.
+            timeout: Override timeout.
+
+        Returns:
+            MontySandboxResult.
+        """
+        # Use textwrap.dedent so Monty doesn't strip leading indentation
+        # and pass the command as a separate argument to avoid injection
+        code = textwrap.dedent(
+            """\
+            import subprocess
+            result = subprocess.run(
+                ['bash', '-c', user_command],
+                capture_output=True,
+                text=True,
+                timeout=user_timeout,
+            )
+            result.stdout if result.returncode == 0 else f'Error: {{result.stderr}}'
+            """
+        )
+        return self.run(
+            code,
+            timeout=timeout,
+            external_functions={
+                "user_command": lambda: command,
+                "user_timeout": lambda: timeout or self.config.max_duration_secs,
+            },
+        )
+
+    def read_file(self, path: str) -> MontySandboxResult:
+        """Read a file from the sandbox filesystem.
+
+        Args:
+            path: Path to read.
+
+        Returns:
+            MontySandboxResult with file content.
+        """
+        sandbox_path = self.sandbox_root / path
+        try:
+            if not sandbox_path.exists():
+                return MontySandboxResult(
+                    stdout=f"File not found: {path}",
+                    stderr="",
+                    exit_code=1,
+                    execution_time=0,
+                    result=None,
+                )
+            content = sandbox_path.read_text()
+            return MontySandboxResult(
+                stdout=content,
+                stderr="",
+                exit_code=0,
+                execution_time=0,
+                result=content,
+            )
+        except Exception as e:
+            return MontySandboxResult(
+                stdout=f"Error reading file: {str(e)}",
+                stderr="",
+                exit_code=1,
+                execution_time=0,
+                result=None,
+            )
+
+    def write_file(self, path: str, content: str) -> MontySandboxResult:
+        """Write content to a file in the sandbox.
+
+        Args:
+            path: Path to write to.
+            content: Content to write.
+
+        Returns:
+            MontySandboxResult.
+        """
+        sandbox_path = self.sandbox_root / path
+        try:
+            sandbox_path.parent.mkdir(parents=True, exist_ok=True)
+            sandbox_path.write_text(content)
+            return MontySandboxResult(
+                stdout=f"Written {len(content)} bytes to {path}",
+                stderr="",
+                exit_code=0,
+                execution_time=0,
+                result=None,
+            )
+        except Exception as e:
+            return MontySandboxResult(
+                stdout=f"Error writing file: {str(e)}",
+                stderr="",
+                exit_code=1,
+                execution_time=0,
+                result=None,
+            )
+
+    def list_dir(self, path: str = ".") -> MontySandboxResult:
+        """List contents of a directory in the sandbox.
+
+        Args:
+            path: Directory path.
+
+        Returns:
+            MontySandboxResult with listing.
+        """
+        sandbox_path = self.sandbox_root / path
+        try:
+            if not sandbox_path.exists():
+                return MontySandboxResult(
+                    stdout=f"Directory not found: {path}",
+                    stderr="",
+                    exit_code=1,
+                    execution_time=0,
+                    result=None,
+                )
+            entries = sorted(sandbox_path.iterdir())
+            lines = []
+            for entry in entries:
+                marker = "/" if entry.is_dir() else ""
+                lines.append(f"{entry.name}{marker}")
+            return MontySandboxResult(
+                stdout="\n".join(lines) if lines else "(empty)",
+                stderr="",
+                exit_code=0,
+                execution_time=0,
+                result=lines,
+            )
+        except Exception as e:
+            return MontySandboxResult(
+                stdout=f"Error listing directory: {str(e)}",
+                stderr="",
+                exit_code=1,
+                execution_time=0,
+                result=None,
+            )

regcode/permissions.py

@@ -0,0 +1,27 @@
+"""Agent permission definitions for controlling tool access."""
+
+from enum import Enum
+
+
+class AgentPermission(str, Enum):
+    """Permissions that control which tools the agent can use."""
+
+    READ = "read"
+    WRITE = "write"
+    DELETE = "delete"
+    EXECUTE = "execute"
+    ALL = "all"
+
+
+_TOOL_PERMISSIONS: dict[str, list[AgentPermission]] = {
+    "python_code": [AgentPermission.EXECUTE],
+    "shell_command": [AgentPermission.EXECUTE],
+    "run_script": [AgentPermission.EXECUTE],
+    "read_file": [AgentPermission.READ],
+    "write_file": [AgentPermission.WRITE],
+    "patch_file": [AgentPermission.WRITE],
+    "list_dir": [AgentPermission.READ],
+    "search_files": [AgentPermission.READ],
+    "browse_dir": [AgentPermission.READ],
+    "search_dir": [AgentPermission.READ],
+}