qwen-sci 0.2.2__py3-none-any.whl

src/harness/src/openharness/sandbox/adapter.py

@@ -0,0 +1,148 @@
+"""Adapter around the ``srt`` sandbox-runtime CLI."""
+
+from __future__ import annotations
+
+import json
+import shlex
+import shutil
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from openharness.config import Settings, load_settings
+from openharness.platforms import get_platform, get_platform_capabilities
+
+
+class SandboxUnavailableError(RuntimeError):
+    """Raised when sandboxing is required but unavailable."""
+
+
+@dataclass(frozen=True)
+class SandboxAvailability:
+    """Computed sandbox-runtime availability for the current environment."""
+
+    enabled: bool
+    available: bool
+    reason: str | None = None
+    command: str | None = None
+
+    @property
+    def active(self) -> bool:
+        """Return whether sandboxing should be applied to child processes."""
+        return self.enabled and self.available
+
+
+def build_sandbox_runtime_config(settings: Settings) -> dict[str, Any]:
+    """Convert OpenHarness settings into an ``srt`` settings payload."""
+    return {
+        "network": {
+            "allowedDomains": list(settings.sandbox.network.allowed_domains),
+            "deniedDomains": list(settings.sandbox.network.denied_domains),
+        },
+        "filesystem": {
+            "allowRead": list(settings.sandbox.filesystem.allow_read),
+            "denyRead": list(settings.sandbox.filesystem.deny_read),
+            "allowWrite": list(settings.sandbox.filesystem.allow_write),
+            "denyWrite": list(settings.sandbox.filesystem.deny_write),
+        },
+    }
+
+
+def get_sandbox_availability(settings: Settings | None = None) -> SandboxAvailability:
+    """Return whether ``srt`` can be used for the current runtime."""
+    resolved_settings = settings or load_settings()
+    if not resolved_settings.sandbox.enabled:
+        return SandboxAvailability(enabled=False, available=False, reason="sandbox is disabled")
+
+    platform_name = get_platform()
+    capabilities = get_platform_capabilities(platform_name)
+    if not capabilities.supports_sandbox_runtime:
+        if platform_name == "windows":
+            reason = "sandbox runtime is not supported on native Windows; use WSL for sandboxed execution"
+        else:
+            reason = f"sandbox runtime is not supported on platform {platform_name}"
+        return SandboxAvailability(enabled=True, available=False, reason=reason)
+
+    enabled_platforms = {name.lower() for name in resolved_settings.sandbox.enabled_platforms}
+    if enabled_platforms and platform_name not in enabled_platforms:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason=f"sandbox is disabled for platform {platform_name} by configuration",
+        )
+
+    srt = shutil.which("srt")
+    if not srt:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason=(
+                "sandbox runtime CLI not found; install it with "
+                "`npm install -g @anthropic-ai/sandbox-runtime`"
+            ),
+        )
+
+    if platform_name in {"linux", "wsl"} and shutil.which("bwrap") is None:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason="bubblewrap (`bwrap`) is required for sandbox runtime on Linux/WSL",
+            command=srt,
+        )
+
+    if platform_name == "macos" and shutil.which("sandbox-exec") is None:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason="`sandbox-exec` is required for sandbox runtime on macOS",
+            command=srt,
+        )
+
+    return SandboxAvailability(enabled=True, available=True, command=srt)
+
+
+def wrap_command_for_sandbox(
+    command: list[str],
+    *,
+    settings: Settings | None = None,
+) -> tuple[list[str], Path | None]:
+    """Wrap an argv list with ``srt`` when sandboxing is active."""
+    resolved_settings = settings or load_settings()
+    if resolved_settings.sandbox.backend == "docker":
+        return command, None
+    availability = get_sandbox_availability(resolved_settings)
+    if not availability.active:
+        if resolved_settings.sandbox.enabled and resolved_settings.sandbox.fail_if_unavailable:
+            raise SandboxUnavailableError(availability.reason or "sandbox runtime is unavailable")
+        return command, None
+
+    settings_path = _write_runtime_settings(build_sandbox_runtime_config(resolved_settings))
+    # The ``srt`` argv form does not reliably preserve child exit codes for shell-style
+    # commands such as ``bash -lc 'exit 1'``. Build a single escaped command string and
+    # pass it through ``-c`` so hook/tool failures still propagate correctly.
+    wrapped = [
+        availability.command or "srt",
+        "--settings",
+        str(settings_path),
+        "-c",
+        shlex.join(command),
+    ]
+    return wrapped, settings_path
+
+
+def _write_runtime_settings(payload: dict[str, Any]) -> Path:
+    """Persist a temporary settings file for one sandboxed child process."""
+    tmp = tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        prefix="openharness-sandbox-",
+        suffix=".json",
+        delete=False,
+    )
+    try:
+        json.dump(payload, tmp)
+        tmp.write("\n")
+    finally:
+        tmp.close()
+    return Path(tmp.name)

src/harness/src/openharness/sandbox/docker_backend.py

@@ -0,0 +1,232 @@
+"""Docker-based sandbox backend for isolated tool execution."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from openharness.config import Settings
+from openharness.platforms import get_platform, get_platform_capabilities
+from openharness.sandbox.adapter import SandboxAvailability, SandboxUnavailableError
+
+logger = logging.getLogger(__name__)
+
+
+def get_docker_availability(settings: Settings) -> SandboxAvailability:
+    """Check whether Docker can be used as a sandbox backend."""
+    if not settings.sandbox.enabled or settings.sandbox.backend != "docker":
+        return SandboxAvailability(
+            enabled=False, available=False, reason="Docker sandbox is not enabled"
+        )
+
+    platform_name = get_platform()
+    capabilities = get_platform_capabilities(platform_name)
+    if not capabilities.supports_docker_sandbox:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason=f"Docker sandbox is not supported on platform {platform_name}",
+        )
+
+    docker = shutil.which("docker")
+    if not docker:
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason="Docker CLI not found; install Docker Desktop or Docker Engine",
+        )
+
+    try:
+        subprocess.run(
+            [docker, "info"],
+            capture_output=True,
+            timeout=5,
+            check=True,
+        )
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired, OSError):
+        return SandboxAvailability(
+            enabled=True,
+            available=False,
+            reason="Docker daemon is not running",
+            command=docker,
+        )
+
+    return SandboxAvailability(enabled=True, available=True, command=docker)
+
+
+@dataclass
+class DockerSandboxSession:
+    """Manages a long-running Docker container for one OpenHarness session."""
+
+    settings: Settings
+    session_id: str
+    cwd: Path
+    _container_name: str = field(init=False)
+    _running: bool = field(init=False, default=False)
+
+    def __post_init__(self) -> None:
+        self._container_name = f"openharness-sandbox-{self.session_id}"
+
+    @property
+    def container_name(self) -> str:
+        return self._container_name
+
+    @property
+    def is_running(self) -> bool:
+        return self._running
+
+    def _build_run_argv(self) -> list[str]:
+        """Build the ``docker run`` argv for container creation."""
+        docker = shutil.which("docker") or "docker"
+        sandbox = self.settings.sandbox
+        docker_cfg = sandbox.docker
+        cwd_str = str(self.cwd.resolve())
+
+        argv = [
+            docker,
+            "run",
+            "-d",
+            "--rm",
+            "--name",
+            self._container_name,
+        ]
+
+        # Docker backend currently supports only fully disabled networking.
+        # Domain-level allow/deny policies exist for the srt backend, but Docker
+        # does not enforce them yet. Fail closed instead of silently widening
+        # egress to unrestricted bridge networking.
+        if sandbox.network.allowed_domains or sandbox.network.denied_domains:
+            logger.warning(
+                "Docker sandbox does not enforce allowed_domains/denied_domains yet; "
+                "keeping network disabled"
+            )
+        argv.extend(["--network", "none"])
+
+        # Resource limits
+        if docker_cfg.cpu_limit > 0:
+            argv.extend(["--cpus", str(docker_cfg.cpu_limit)])
+        if docker_cfg.memory_limit:
+            argv.extend(["--memory", docker_cfg.memory_limit])
+
+        # Bind-mount project directory at the same path
+        argv.extend(["-v", f"{cwd_str}:{cwd_str}"])
+        argv.extend(["-w", cwd_str])
+
+        # Extra mounts
+        for mount in docker_cfg.extra_mounts:
+            argv.extend(["-v", mount])
+
+        # Extra environment variables
+        for key, value in docker_cfg.extra_env.items():
+            argv.extend(["-e", f"{key}={value}"])
+
+        argv.extend([docker_cfg.image, "tail", "-f", "/dev/null"])
+        return argv
+
+    async def start(self) -> None:
+        """Create and start the sandbox container."""
+        from openharness.sandbox.docker_image import ensure_image_available
+
+        docker_cfg = self.settings.sandbox.docker
+        available = await ensure_image_available(
+            docker_cfg.image, docker_cfg.auto_build_image
+        )
+        if not available:
+            raise SandboxUnavailableError(
+                f"Docker image {docker_cfg.image!r} is not available and "
+                "auto_build_image is disabled"
+            )
+
+        argv = self._build_run_argv()
+        logger.info("Starting Docker sandbox: %s", " ".join(argv))
+
+        process = await asyncio.create_subprocess_exec(
+            *argv,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+        if process.returncode != 0:
+            msg = stderr.decode("utf-8", errors="replace").strip()
+            raise SandboxUnavailableError(f"Failed to start Docker sandbox: {msg}")
+
+        self._running = True
+        logger.info("Docker sandbox started: %s", self._container_name)
+
+    async def stop(self) -> None:
+        """Stop and remove the sandbox container."""
+        if not self._running:
+            return
+        docker = shutil.which("docker") or "docker"
+        try:
+            process = await asyncio.create_subprocess_exec(
+                docker,
+                "stop",
+                "-t",
+                "5",
+                self._container_name,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            await asyncio.wait_for(process.communicate(), timeout=15)
+        except (asyncio.TimeoutError, OSError) as exc:
+            logger.warning("Error stopping Docker sandbox: %s", exc)
+        finally:
+            self._running = False
+            logger.info("Docker sandbox stopped: %s", self._container_name)
+
+    def stop_sync(self) -> None:
+        """Synchronous stop for use in atexit handlers."""
+        if not self._running:
+            return
+        docker = shutil.which("docker") or "docker"
+        try:
+            subprocess.run(
+                [docker, "stop", "-t", "3", self._container_name],
+                capture_output=True,
+                timeout=10,
+            )
+        except (subprocess.TimeoutExpired, OSError):
+            pass
+        finally:
+            self._running = False
+
+    async def exec_command(
+        self,
+        argv: list[str],
+        *,
+        cwd: str | Path,
+        stdin: int | None = None,
+        stdout: int | None = None,
+        stderr: int | None = None,
+        env: dict[str, str] | None = None,
+    ) -> asyncio.subprocess.Process:
+        """Execute a command inside the sandbox container.
+
+        Returns an ``asyncio.subprocess.Process`` with the same interface as
+        ``asyncio.create_subprocess_exec``.
+        """
+        if not self._running:
+            raise SandboxUnavailableError("Docker sandbox session is not running")
+
+        docker = shutil.which("docker") or "docker"
+        cmd: list[str] = [docker, "exec"]
+        cmd.extend(["-w", str(Path(cwd).resolve())])
+
+        if env:
+            for key, value in env.items():
+                cmd.extend(["-e", f"{key}={value}"])
+
+        cmd.append(self._container_name)
+        cmd.extend(argv)
+
+        return await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=stdin,
+            stdout=stdout,
+            stderr=stderr,
+        )

src/harness/src/openharness/sandbox/docker_image.py

@@ -0,0 +1,103 @@
+"""Docker image availability and build helpers."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import shutil
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_IMAGE = "openharness-sandbox:latest"
+
+_DOCKERFILE_CONTENT = """\
+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    ripgrep bash git && \\
+    rm -rf /var/lib/apt/lists/*
+RUN useradd -m -s /bin/bash ohuser
+USER ohuser
+"""
+
+
+def get_dockerfile_content() -> str:
+    """Return the default Dockerfile content for the sandbox image."""
+    return _DOCKERFILE_CONTENT
+
+
+async def _image_exists(image: str) -> bool:
+    """Check whether a Docker image exists locally."""
+    docker = shutil.which("docker") or "docker"
+    process = await asyncio.create_subprocess_exec(
+        docker,
+        "image",
+        "inspect",
+        image,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    await process.communicate()
+    return process.returncode == 0
+
+
+async def build_default_image(image: str = _DEFAULT_IMAGE) -> bool:
+    """Build the default sandbox image from the bundled Dockerfile.
+
+    Returns ``True`` on success, ``False`` on failure.
+    """
+    docker = shutil.which("docker") or "docker"
+    dockerfile_path = Path(__file__).parent / "Dockerfile"
+
+    if dockerfile_path.exists():
+        cmd = [docker, "build", "-t", image, "-f", str(dockerfile_path), str(dockerfile_path.parent)]
+    else:
+        # Fallback: pipe Dockerfile content via stdin
+        cmd = [docker, "build", "-t", image, "-"]
+
+    logger.info("Building Docker sandbox image %r ...", image)
+
+    if dockerfile_path.exists():
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    else:
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await process.communicate(input=_DOCKERFILE_CONTENT.encode("utf-8"))
+        if process.returncode == 0:
+            logger.info("Docker sandbox image %r built successfully", image)
+            return True
+        logger.warning("Failed to build Docker sandbox image %r", image)
+        return False
+
+    _, stderr_bytes = await process.communicate()
+    if process.returncode == 0:
+        logger.info("Docker sandbox image %r built successfully", image)
+        return True
+
+    logger.warning(
+        "Failed to build Docker sandbox image %r: %s",
+        image,
+        stderr_bytes.decode("utf-8", errors="replace").strip(),
+    )
+    return False
+
+
+async def ensure_image_available(image: str, auto_build: bool) -> bool:
+    """Ensure the sandbox image exists, optionally building it.
+
+    Returns ``True`` if the image is available.
+    """
+    if await _image_exists(image):
+        return True
+    if not auto_build:
+        logger.warning("Docker image %r not found and auto_build_image is disabled", image)
+        return False
+    return await build_default_image(image)

src/harness/src/openharness/sandbox/path_validator.py

@@ -0,0 +1,37 @@
+"""Path boundary enforcement for sandbox file operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def validate_sandbox_path(
+    path: Path,
+    cwd: Path,
+    extra_allowed: list[str] | None = None,
+) -> tuple[bool, str]:
+    """Check whether *path* falls within the sandbox boundary.
+
+    Returns ``(True, "")`` when the path is allowed, or ``(False, reason)``
+    when it falls outside the permitted directories.
+    """
+    resolved = path.resolve()
+    resolved_cwd = cwd.resolve()
+
+    # Primary check: path must be within the project directory
+    try:
+        resolved.relative_to(resolved_cwd)
+        return True, ""
+    except ValueError:
+        pass
+
+    # Secondary: check extra allowed paths (from filesystem settings)
+    for allowed in extra_allowed or []:
+        allowed_path = Path(allowed).expanduser().resolve()
+        try:
+            resolved.relative_to(allowed_path)
+            return True, ""
+        except ValueError:
+            continue
+
+    return False, f"path {resolved} is outside the sandbox boundary ({resolved_cwd})"

src/harness/src/openharness/sandbox/session.py

@@ -0,0 +1,63 @@
+"""Module-level Docker sandbox session registry."""
+
+from __future__ import annotations
+
+import atexit
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from openharness.config import Settings
+    from openharness.sandbox.docker_backend import DockerSandboxSession
+
+logger = logging.getLogger(__name__)
+
+_active_session: DockerSandboxSession | None = None
+
+
+def get_docker_sandbox():
+    """Return the active Docker sandbox session, or ``None``."""
+    return _active_session
+
+
+def is_docker_sandbox_active() -> bool:
+    """Return whether a Docker sandbox session is currently running."""
+    return _active_session is not None and _active_session.is_running
+
+
+async def start_docker_sandbox(
+    settings: Settings,
+    session_id: str,
+    cwd: Path,
+) -> None:
+    """Start a Docker sandbox session for the current OpenHarness session."""
+    global _active_session  # noqa: PLW0603
+
+    from openharness.sandbox.docker_backend import DockerSandboxSession, get_docker_availability
+
+    availability = get_docker_availability(settings)
+    if not availability.available:
+        if settings.sandbox.fail_if_unavailable:
+            from openharness.sandbox.adapter import SandboxUnavailableError
+
+            raise SandboxUnavailableError(
+                availability.reason or "Docker sandbox is unavailable"
+            )
+        logger.warning("Docker sandbox unavailable: %s", availability.reason)
+        return
+
+    session = DockerSandboxSession(settings=settings, session_id=session_id, cwd=cwd)
+    await session.start()
+    _active_session = session
+
+    # Safety net: stop the container if the process exits without close_runtime()
+    atexit.register(session.stop_sync)
+
+
+async def stop_docker_sandbox() -> None:
+    """Stop the active Docker sandbox session, if any."""
+    global _active_session  # noqa: PLW0603
+    if _active_session is not None:
+        await _active_session.stop()
+        _active_session = None

src/harness/src/openharness/services/__init__.py

@@ -0,0 +1,30 @@
+"""Service exports."""
+
+from openharness.services.compact import (
+    build_post_compact_messages,
+    compact_conversation,
+    compact_messages,
+    estimate_conversation_tokens,
+    summarize_messages,
+)
+from openharness.services.session_storage import (
+    export_session_markdown,
+    get_project_session_dir,
+    load_session_snapshot,
+    save_session_snapshot,
+)
+from openharness.services.token_estimation import estimate_message_tokens, estimate_tokens
+
+__all__ = [
+    "compact_messages",
+    "compact_conversation",
+    "build_post_compact_messages",
+    "estimate_conversation_tokens",
+    "estimate_message_tokens",
+    "estimate_tokens",
+    "export_session_markdown",
+    "get_project_session_dir",
+    "load_session_snapshot",
+    "save_session_snapshot",
+    "summarize_messages",
+]

src/harness/src/openharness/services/autodream/__init__.py

@@ -0,0 +1,34 @@
+"""Automatic memory consolidation (auto-dream)."""
+
+from openharness.services.autodream.backup import (
+    create_memory_backup,
+    diff_memory_dirs,
+    format_memory_diff,
+    latest_memory_backup,
+    restore_memory_backup,
+)
+from openharness.services.autodream.lock import (
+    list_sessions_touched_since,
+    read_last_consolidated_at,
+    record_consolidation,
+    rollback_consolidation_lock,
+    try_acquire_consolidation_lock,
+)
+from openharness.services.autodream.prompt import build_consolidation_prompt
+from openharness.services.autodream.service import execute_auto_dream, start_dream_now
+
+__all__ = [
+    "build_consolidation_prompt",
+    "create_memory_backup",
+    "diff_memory_dirs",
+    "execute_auto_dream",
+    "format_memory_diff",
+    "latest_memory_backup",
+    "list_sessions_touched_since",
+    "read_last_consolidated_at",
+    "record_consolidation",
+    "restore_memory_backup",
+    "rollback_consolidation_lock",
+    "start_dream_now",
+    "try_acquire_consolidation_lock",
+]