rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download runtime_environment/runner.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 11.3 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/runtime_environment/runner.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/runtime_environment/runner.py
-
curl -L -o runner.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/runtime_environment/runner.py
11.3 kB
| """ | |
| Execution Runner Engines. | |
| Supports fast local subprocess execution and isolated air-gapped Docker sandboxes. | |
| """ | |
| import os | |
| import shutil | |
| import subprocess | |
| import sys | |
| import tempfile | |
| import time | |
| import uuid | |
| from typing import Dict, Optional | |
| from language_core.runtime_events import redact_sensitive_text | |
| from runtime_environment.active_runs import GLOBAL_ACTIVE_RUNS | |
| from runtime_environment.env_injection import ( | |
| create_ephemeral_docker_env_file, | |
| remove_ephemeral_env_file, | |
| resolve_runner_workspace_env, | |
| ) | |
| from runtime_environment.process_utils import ( | |
| DEFAULT_PACKAGE_CACHE_DIR, ExecutionResult, build_docker_run_command, | |
| get_sanitized_env, kill_process_tree, resolve_package_cache_dir, | |
| ) | |
| class LocalSubprocessRunner: | |
| """Fast local subprocess execution engine with active tracking, credential scrubbing, and tree cleanup.""" | |
| def __init__( | |
| self, | |
| timeout_sec: float = 5.0, | |
| run_id: Optional[str] = None, | |
| package_cache_dir: Optional[str] = None, | |
| workspace_env: Optional[Dict[str, str]] = None, | |
| ): | |
| self.timeout_sec = min(float(timeout_sec), 5.0) if timeout_sec and float(timeout_sec) > 0 else 5.0 | |
| self.run_id = run_id | |
| self.package_cache_dir = package_cache_dir | |
| self.workspace_env = workspace_env | |
| def execute_code(self, python_code: str) -> ExecutionResult: | |
| start_time = time.perf_counter() | |
| with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as temp_file: | |
| temp_file.write(python_code) | |
| temp_path = temp_file.name | |
| proc = None | |
| try: | |
| proc = subprocess.Popen( | |
| [sys.executable, temp_path], | |
| stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, | |
| cwd=tempfile.gettempdir(), | |
| env=get_sanitized_env(package_cache_dir=self.package_cache_dir, workspace_env=self.workspace_env), | |
| ) | |
| if self.run_id: | |
| GLOBAL_ACTIVE_RUNS.record_process(self.run_id, proc) | |
| stdout, stderr = proc.communicate(timeout=self.timeout_sec) | |
| return ExecutionResult( | |
| success=(proc.returncode == 0), exit_code=proc.returncode, | |
| stdout=redact_sensitive_text(stdout or ""), stderr=redact_sensitive_text(stderr or ""), | |
| duration_ms=(time.perf_counter() - start_time) * 1000.0, mode="local_subprocess", | |
| ) | |
| except subprocess.TimeoutExpired: | |
| if proc: | |
| try: | |
| kill_process_tree(proc) | |
| except Exception: | |
| pass | |
| try: | |
| stdout, stderr = proc.communicate(timeout=1.0) | |
| except Exception: | |
| stdout, stderr = "", "" | |
| else: | |
| stdout, stderr = "", "" | |
| stdout_str = stdout if isinstance(stdout, str) else (stdout.decode() if stdout else "") | |
| return ExecutionResult( | |
| success=False, exit_code=-1, stdout=stdout_str, | |
| stderr=f"Execution timed out after {self.timeout_sec} seconds.", | |
| duration_ms=(time.perf_counter() - start_time) * 1000.0, mode="local_subprocess", | |
| ) | |
| except Exception as exc: | |
| return ExecutionResult( | |
| success=False, exit_code=-1, stdout="", stderr=str(exc), | |
| duration_ms=(time.perf_counter() - start_time) * 1000.0, mode="local_subprocess", | |
| ) | |
| finally: | |
| if os.path.exists(temp_path): | |
| try: | |
| os.remove(temp_path) | |
| except OSError: | |
| pass | |
| class DockerSandboxRunner: | |
| """Isolated container engine with manylinux glibc compatibility, memory/CPU caps, and --network none.""" | |
| def __init__( | |
| self, | |
| image_name: str = "python:3.12-slim", | |
| memory_limit: str = "128m", | |
| cpu_limit: str = "0.5", | |
| timeout_sec: float = 5.0, | |
| run_id: Optional[str] = None, | |
| package_cache_dir: Optional[str] = None, | |
| workspace_env: Optional[Dict[str, str]] = None, | |
| ): | |
| self.image_name = image_name | |
| self.memory_limit = memory_limit | |
| self.cpu_limit = cpu_limit | |
| self.timeout_sec = min(float(timeout_sec), 5.0) if timeout_sec and float(timeout_sec) > 0 else 5.0 | |
| self.run_id = run_id | |
| self.package_cache_dir = package_cache_dir | |
| self.workspace_env = workspace_env | |
| def is_docker_available() -> bool: | |
| if shutil.which("docker") is None: | |
| return False | |
| try: | |
| res = subprocess.run(["docker", "info"], capture_output=True, timeout=3.0) | |
| return res.returncode == 0 | |
| except Exception: | |
| return False | |
| def build_docker_command(self, temp_dir: str, container_name: str, env_file: Optional[str] = None) -> list[str]: | |
| """Construct air-gapped Docker command with optional read-only cached packages mount.""" | |
| return build_docker_run_command( | |
| temp_dir=temp_dir, | |
| container_name=container_name, | |
| image_name=self.image_name, | |
| memory_limit=self.memory_limit, | |
| cpu_limit=self.cpu_limit, | |
| package_cache_dir=self.package_cache_dir, | |
| env_file=env_file, | |
| ) | |
| def execute_code(self, python_code: str) -> ExecutionResult: | |
| if not self.is_docker_available(): | |
| raise RuntimeError( | |
| "[ERR-SANDBOX-UNAVAILABLE] Docker daemon is not running or accessible on the host machine." | |
| ) | |
| start_time = time.perf_counter() | |
| temp_dir = tempfile.mkdtemp(prefix="alli_sandbox_") | |
| script_path = os.path.join(temp_dir, "script.py") | |
| with open(script_path, "w", encoding="utf-8") as file: | |
| file.write(python_code) | |
| container_name = f"alli_sandbox_{uuid.uuid4().hex[:12]}" | |
| if self.run_id: | |
| GLOBAL_ACTIVE_RUNS.record_container(self.run_id, container_name) | |
| env_file = create_ephemeral_docker_env_file(resolve_runner_workspace_env(self.workspace_env)) | |
| docker_cmd = self.build_docker_command(temp_dir, container_name, env_file=env_file) | |
| try: | |
| process = subprocess.run(docker_cmd, capture_output=True, text=True, timeout=self.timeout_sec) | |
| duration_ms = (time.perf_counter() - start_time) * 1000.0 | |
| if process.returncode == 125: | |
| raise RuntimeError( | |
| f"[ERR-SANDBOX-UNAVAILABLE] Docker daemon failed to start sandbox container: {process.stderr.strip()}" | |
| ) | |
| return ExecutionResult( | |
| success=(process.returncode == 0), | |
| exit_code=process.returncode, | |
| stdout=redact_sensitive_text(process.stdout), | |
| stderr=redact_sensitive_text(process.stderr), | |
| duration_ms=duration_ms, | |
| mode="docker_sandbox", | |
| memory_limit=self.memory_limit, | |
| cpu_limit=self.cpu_limit, | |
| ) | |
| except subprocess.TimeoutExpired: | |
| subprocess.run(["docker", "rm", "-f", container_name], capture_output=True, timeout=5.0) | |
| duration_ms = (time.perf_counter() - start_time) * 1000.0 | |
| return ExecutionResult( | |
| success=False, | |
| exit_code=-1, | |
| stdout="", | |
| stderr=f"Docker container timed out after {self.timeout_sec}s and was terminated.", | |
| duration_ms=duration_ms, | |
| mode="docker_sandbox", | |
| memory_limit=self.memory_limit, | |
| cpu_limit=self.cpu_limit, | |
| ) | |
| except RuntimeError: | |
| raise | |
| except Exception as exc: | |
| raise RuntimeError(f"[ERR-SANDBOX-UNAVAILABLE] Docker sandbox execution failed: {exc}") from exc | |
| finally: | |
| remove_ephemeral_env_file(env_file) | |
| try: | |
| subprocess.run(["docker", "rm", "-f", container_name], capture_output=True, timeout=5.0) | |
| except Exception: | |
| pass | |
| shutil.rmtree(temp_dir, ignore_errors=True) | |
| # Phase 15 Production Sandbox Alias | |
| AirGappedDockerRunner = DockerSandboxRunner | |
| class RuntimeRunner: | |
| """Unified fail-closed runtime dispatcher with zero silent Docker-to-host downgrades.""" | |
| def __init__( | |
| self, | |
| default_mode: str = "auto", | |
| timeout_sec: float = 5.0, | |
| run_id: Optional[str] = None, | |
| package_cache_dir: Optional[str] = None, | |
| sandbox_required: bool = False, | |
| workspace_env: Optional[Dict[str, str]] = None, | |
| ): | |
| self.default_mode = default_mode | |
| self.run_id = run_id | |
| self.package_cache_dir = package_cache_dir | |
| self.sandbox_required = sandbox_required | |
| self.local_runner = LocalSubprocessRunner( | |
| timeout_sec=timeout_sec, run_id=run_id, package_cache_dir=package_cache_dir, workspace_env=workspace_env | |
| ) | |
| self.docker_runner = DockerSandboxRunner( | |
| timeout_sec=timeout_sec, run_id=run_id, package_cache_dir=package_cache_dir, workspace_env=workspace_env | |
| ) | |
| def _run_docker_strict(self, python_code: str, enforcement_msg: str) -> ExecutionResult: | |
| if not self.docker_runner.is_docker_available(): | |
| raise RuntimeError(f"[ERR-SANDBOX-UNAVAILABLE] {enforcement_msg}") | |
| try: | |
| return self.docker_runner.execute_code(python_code) | |
| except RuntimeError as exc: | |
| msg = str(exc) | |
| if "[ERR-SANDBOX-UNAVAILABLE]" in msg: | |
| raise | |
| raise RuntimeError(f"[ERR-SANDBOX-UNAVAILABLE] Docker sandbox execution failed: {msg}") from exc | |
| def run(self, python_code: str, mode: Optional[str] = None, sandbox_required: Optional[bool] = None) -> ExecutionResult: | |
| selected_mode = (mode or self.default_mode or "auto").strip().lower() | |
| enforce_docker = os.environ.get("ENFORCE_DOCKER_SANDBOX", "false").lower() in ("true", "1", "yes") | |
| is_production = os.environ.get("STAGE", "development").lower() == "production" | |
| require_sandbox = self.sandbox_required if sandbox_required is None else bool(sandbox_required) | |
| if enforce_docker or require_sandbox or (is_production and selected_mode in ("docker", "docker_sandbox", "auto")): | |
| return self._run_docker_strict( | |
| python_code, | |
| "Docker sandbox is enforced (production environment, ENFORCE_DOCKER_SANDBOX=true, or sandbox_required=True), " | |
| "but Docker daemon is not running or accessible. Execution failed closed for security.", | |
| ) | |
| if selected_mode in ("docker", "docker_sandbox"): | |
| return self._run_docker_strict( | |
| python_code, | |
| "Docker sandbox was explicitly requested, but Docker daemon is not available or misconfigured. Execution failed closed.", | |
| ) | |
| if selected_mode == "auto": | |
| if self.docker_runner.is_docker_available(): | |
| return self.docker_runner.execute_code(python_code) | |
| return self.local_runner.execute_code(python_code) | |
| return self.local_runner.execute_code(python_code) | |