verifiers 0.3.2.dev167__tar.gz → 0.3.2.dev169__tar.gz

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev167
+Version: 0.3.2.dev169
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers
@@ -36,7 +36,7 @@ Requires-Dist: numpy>=2.1.0
 Requires-Dist: openai<3.0.0,>=2.54.0
 Requires-Dist: prime-pydantic-config[toml]>=0.4.3
 Requires-Dist: prime-runs>=0.1.3
-Requires-Dist: prime-sandboxes>=0.3.0
+Requires-Dist: prime-sandboxes>=0.4.1
 Requires-Dist: prime-tunnel>=0.1.8
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: pyzmq>=27.1.0
@@ -46,6 +46,8 @@ Requires-Dist: tenacity>=8.5.0
 Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: typing-extensions>=4.12.2
 Requires-Dist: uvicorn>=0.52.0
+Provides-Extra: e2b
+Requires-Dist: e2b<3,>=2.35.0; extra == 'e2b'
 Provides-Extra: harbor
 Requires-Dist: harbor==0.21.0; (python_full_version >= '3.12') and extra == 'harbor'
 Provides-Extra: modal

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/pyproject.toml

@@ -33,7 +33,7 @@ dependencies = [
     "math-verify>=0.8.0",
     "openai>=2.54.0,<3.0.0",
     "prime-tunnel>=0.1.8",
-    "prime-sandboxes>=0.3.0",
+    "prime-sandboxes>=0.4.1",
     "prime-runs>=0.1.3",
     "pydantic>=2.12.3",
     "rich>=11.0.0",
@@ -100,6 +100,11 @@ harbor = [
 modal = [
     "modal>=1.5.4",
 ]
+e2b = [
+    # <3: the runtime swaps the SDK command handle's private stream decoders for
+    # byte-accurate live output (see runtimes/e2b.py _byte_handle).
+    "e2b>=2.35.0,<3",
+]
 openenv = [
     "openenv>=0.4.1",
 ]
@@ -228,6 +233,7 @@ markers = [
     "apptainer: v1 e2e cases touching the apptainer runtime",
     "prime: v1 e2e cases touching the prime runtime (real sandbox + tunnel; local-only, excluded in CI)",
     "modal: v1 e2e cases touching the modal runtime (local-only setup; excluded in CI)",
+    "e2b: v1 e2e cases touching the e2b runtime (real sandbox; local-only, excluded in CI)",
     "colocated: v1 e2e cases with a user/tool server colocated in the harness runtime",
     "null: v1 e2e cases on the null harness",
     "bash: v1 e2e cases on the bash harness",

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/tests/v1/conftest.py

@@ -16,20 +16,21 @@ one without `indirect=True` fails loudly.
 
 Every combination carries its axes' pytest marks, so subsets select with `-m`:
 
-    uv run pytest tests/v1 -n auto                                # everything (needs modal setup)
+    uv run pytest tests/v1 -n auto                                # everything (needs remote setup)
     uv run pytest tests/v1 -n auto -m "not e2e"                   # deterministic CI matrix
-    uv run pytest tests/v1 -n auto -m "e2e and not prime and not modal"  # live CI job
+    uv run pytest tests/v1 -n auto -m "e2e and not prime and not modal and not e2b"  # live CI job
     uv run pytest tests/v1 -n auto -m docker                      # any case touching the docker runtime
     uv run pytest tests/v1 -n auto -m bash                        # only the bash harness
     uv run pytest tests/v1 -n auto -m prime                       # only prime (real sandboxes; local)
     uv run pytest tests/v1 -n auto -m modal                       # only modal (needs local setup)
+    uv run pytest tests/v1 -n auto -m e2b                         # only e2b (real sandboxes; local)
 
-Marks: runtimes `subprocess` / `docker` / `podman` / `apptainer` / `prime` / `modal`, placement `colocated`,
+Marks: runtimes `subprocess` / `docker` / `podman` / `apptainer` / `prime` / `modal` / `e2b`, placement `colocated`,
 harnesses `null` / `bash` / `rlm` / `kimi_code` / `pi` / `openclaw` / `codex` /
 `claude_code` / `hermes_agent`.
 A mark is applied per axis, so it selects every case touching that value on ANY axis; for one exact
 combination use `-k` on the test id (e.g. `-k "harness-in-docker-with-tool-in-subprocess"`).
-prime/modal provision real remote sandboxes (slow, infra-flaky, need setup), so they're local-only.
+prime/modal/e2b provision real remote sandboxes (slow, infra-flaky, need setup), so they're local-only.
 CI runs deterministic tests across the Python matrix and the remaining live E2Es once.
 """
 

verifiers-0.3.2.dev169/tests/v1/fixtures/agent_user_v1.py

@@ -0,0 +1,82 @@
+"""agent-user-v1: a scripted, model-free agent that runs as a non-root user and tries root actions.
+
+Task setup runs as root: it creates the task's `agent_user` (images normally ship one),
+plants a root-only secret, and hands the workdir to that user. The scripted harness then runs
+as that user, attempts four actions only root may take, and records each outcome in the
+workdir. The reward is 1 only if every root action was denied while the agent still saw the
+secret and could write its workspace.
+Needs a runtime that can switch users (docker or prime).
+"""
+
+import json
+
+import verifiers.v1 as vf
+from verifiers.v1.clients import ModelContext
+from verifiers.v1.configs.harness import HarnessConfig
+from verifiers.v1.harness import Harness
+from verifiers.v1.runtimes import ProgramResult, Runtime
+
+__all__ = ["AgentUserTaskset", "ScriptedAgentUserHarness"]
+
+AGENT_USER = "vf-agent"
+SECRET = "/opt/vf-agent-user-secret"
+REPORT = "agent-user-report.json"
+ROOT_ACTIONS = ("read_secret", "write_etc", "chmod_secret", "signal_init")
+
+SETUP = (
+    f"useradd -m {AGENT_USER} && echo secret > {SECRET} && chmod 600 {SECRET} "
+    f"&& chown -R {AGENT_USER} ."
+)
+
+PROBE = f"""
+r() {{ "$@" >/dev/null 2>&1 && echo ok || echo denied; }}
+printf '{{"user":"%s","secret_exists":"%s","read_secret":"%s","write_etc":"%s","chmod_secret":"%s","signal_init":"%s","write_workdir":"%s"}}' \\
+  "$(id -un)" "$(r test -e {SECRET})" "$(r cat {SECRET})" "$(r touch /etc/vf-agent-user-probe)" \\
+  "$(r chmod 644 {SECRET})" "$(r kill -0 1)" "$(r touch probe)" > {REPORT}
+"""
+
+
+class ScriptedAgentUserHarness(Harness[HarnessConfig]):
+    async def launch(
+        self,
+        ctx: ModelContext,
+        trace: vf.Trace,
+        runtime: Runtime,
+        endpoint: str,
+        secret: str,
+        mcp_urls: dict[str, str],
+        data: vf.TaskData,
+        tool_interception_url: str | None = None,
+    ) -> ProgramResult:
+        return await runtime.run_program(["sh", "-c", PROBE], {})
+
+
+class AgentUserTask(vf.Task):
+    async def setup(self, trace: vf.Trace, runtime: Runtime) -> None:
+        result = await runtime.run(["sh", "-c", SETUP], {})
+        if result.exit_code != 0:
+            raise RuntimeError(f"root setup failed: {result.stderr}")
+
+    @vf.reward(weight=1.0)
+    async def root_actions_denied(self, trace: vf.Trace, runtime: Runtime) -> float:
+        report = json.loads(await runtime.read(REPORT))
+        trace.info["agent_user_report"] = report
+        return float(
+            report["user"] == AGENT_USER
+            and report["secret_exists"] == "ok"
+            and report["write_workdir"] == "ok"
+            and all(report[action] == "denied" for action in ROOT_ACTIONS)
+        )
+
+
+class AgentUserTaskset(vf.Taskset[AgentUserTask, vf.TasksetConfig]):
+    def load(self) -> list[AgentUserTask]:
+        return [
+            AgentUserTask(
+                vf.TaskData(
+                    idx=0,
+                    prompt="Scripted: try root-only actions as a non-root user.",
+                    agent_user=AGENT_USER,
+                )
+            )
+        ]

verifiers-0.3.2.dev169/tests/v1/test_configs.py

@@ -0,0 +1,95 @@
+"""Every checked-in v1 eval config parses.
+
+Mirrors prime-rl's config test: glob the configs and assert each validates into its config
+type. The root `configs/*.toml` are the `uv run vf-eval @ <file>` v1 configs (EvalConfig).
+"""
+
+import tomllib
+from pathlib import Path
+
+import pytest
+
+from verifiers.v1.configs.cli.eval import EvalConfig
+from verifiers.v1.runtimes import E2BConfig
+from verifiers.v1.runtimes.e2b import _egress_update
+
+CONFIGS = sorted((Path(__file__).resolve().parents[2] / "configs").glob("*.toml"))
+
+
+@pytest.mark.parametrize("path", CONFIGS, ids=lambda p: p.name)
+def test_eval_config_parses(path: Path) -> None:
+    config = EvalConfig.model_validate(tomllib.load(path.open("rb")))
+    assert config.env.taskset.id
+
+
+@pytest.mark.parametrize(
+    "rule",
+    [
+        "",
+        "https://api.example.com",
+        "example.com:8443",
+        "example.com/path",
+        "user@example.com",
+        "10.0.0.0/99",
+        "example..com",
+    ],
+)
+def test_e2b_config_rejects_unenforceable_egress_rules(rule: str) -> None:
+    with pytest.raises(ValueError, match="allow rules"):
+        E2BConfig(allow=[rule])
+
+
+@pytest.mark.parametrize("rule", ["api.example.com", "*.example.com"])
+def test_e2b_config_rejects_hostname_block_rules(rule: str) -> None:
+    with pytest.raises(ValueError, match="block rules must be IP addresses or CIDR"):
+        E2BConfig(block=[rule])
+
+
+@pytest.mark.parametrize(
+    "rule",
+    [
+        "api.example.com",
+        "*.example.com",
+        "10.0.0.1",
+        "10.0.0.0/24",
+        "2001:db8::1",
+        "2001:db8::/32",
+    ],
+)
+def test_e2b_config_accepts_supported_egress_rules(rule: str) -> None:
+    assert E2BConfig(allow=[rule]).allow == [rule]
+
+
+@pytest.mark.parametrize(
+    "rule", ["10.0.0.1", "10.0.0.0/24", "2001:db8::1", "2001:db8::/32"]
+)
+def test_e2b_config_accepts_supported_block_rules(rule: str) -> None:
+    assert E2BConfig(block=[rule]).block == [rule]
+
+
+def test_e2b_egress_update_states_the_complete_policy() -> None:
+    # The security-critical policy table: whether a "restricted" sandbox actually
+    # gets a deny-everything floor, with framework routes kept reachable. No e2e
+    # placement runs network-restricted, so this table is pinned here.
+    routes = ["https://tunnel.example.com/intercept"]
+
+    unrestricted = _egress_update(E2BConfig(), None)
+    assert unrestricted == {"allow_internet_access": True}
+
+    blocklist = _egress_update(E2BConfig(block=["203.0.113.0/24"]), routes)
+    assert blocklist == {"deny_out": ["203.0.113.0/24"]}
+
+    allowlist = _egress_update(E2BConfig(allow=["api.example.com"]), routes)
+    assert allowlist == {
+        "allow_out": ["tunnel.example.com", "api.example.com"],
+        "deny_out": ["0.0.0.0/0"],
+    }
+
+    framework_only = _egress_update(E2BConfig(allow=[]), routes)
+    assert framework_only == {
+        "allow_out": ["tunnel.example.com"],
+        "deny_out": ["0.0.0.0/0"],
+    }
+
+    no_routes = _egress_update(E2BConfig(allow=[]), [])
+    assert no_routes == {"allow_internet_access": False}

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/tests/v1/test_e2e.py

@@ -2,8 +2,8 @@
 
 Placement coverage is pairwise (see tests/v1/conftest.py): each list below names the
 combinations a test runs — every axis value at least once plus the cross-boundary pairs
-with distinct networking — instead of fanning the full cross product. prime/modal rows
-are local-only (their marks are excluded in CI)."""
+with distinct networking — instead of fanning the full cross product. prime/modal/e2b
+rows are local-only (their marks are excluded in CI)."""
 
 import shutil
 import subprocess
@@ -142,6 +142,7 @@ CHAT_PLACEMENTS = [
     ),
     pair("bash", "prime", "bash-harness-in-prime"),
     pair("bash", "modal", "bash-harness-in-modal"),
+    pair("bash", "e2b", "bash-harness-in-e2b"),
 ]
 
 # harness x harness runtime for the shell task: every coding agent once (null is a chat
@@ -176,6 +177,7 @@ AGENTIC_PLACEMENTS = [
         marks=[mark.bash, mark.modal],
         id="bash-harness-in-modal-framework-only",
     ),
+    pair("bash", "e2b", "bash-harness-in-e2b"),
 ]
 
 # The scripted user runs in the eval process itself (no placement axis); the harness
@@ -185,6 +187,13 @@ USER_RUNTIMES = [
     pytest.param("docker", marks=[mark.docker], id="harness-in-docker"),
     pytest.param("prime", marks=[mark.prime], id="harness-in-prime"),
     pytest.param("modal", marks=[mark.modal], id="harness-in-modal"),
+    pytest.param("e2b", marks=[mark.e2b], id="harness-in-e2b"),
+]
+
+# Runtimes that can switch users (`Runtime.with_user`).
+AGENT_USER_RUNTIMES = [
+    pytest.param("docker", marks=[mark.docker], id="harness-in-docker"),
+    pytest.param("prime", marks=[mark.prime], id="harness-in-prime"),
 ]
 
 # ACP-backed harnesses: each must preserve an exchange across interaction segments and
@@ -218,6 +227,13 @@ ACP_RESUME_PLACEMENTS = [
     ),
     pair("openclaw", "docker", "openclaw-acp-in-docker"),
     pair("rlm", "prime", "rlm-acp-in-prime-vm"),
+    # Give RLM 2 GB for ACP session startup.
+    pytest.param(
+        "rlm",
+        {"type": "e2b", "memory": 2.0},
+        marks=[mark.rlm, mark.e2b],
+        id="rlm-acp-in-e2b",
+    ),
     pytest.param(
         "prime-agent",
         "prime",
@@ -247,6 +263,8 @@ TOOL_PLACEMENTS = [
     pair("prime", "colocated", "harness-in-prime-with-tool-colocated"),
     pair("modal", "colocated", "harness-in-modal-with-tool-colocated"),
     pair("subprocess", "modal", "harness-in-subprocess-with-tool-in-modal"),
+    pair("e2b", "colocated", "harness-in-e2b-with-tool-colocated"),
+    pair("subprocess", "e2b", "harness-in-subprocess-with-tool-in-e2b"),
 ]
 
 # The state channel rides the same reachability as TOOL_PLACEMENTS; cover each axis
@@ -256,6 +274,7 @@ TOOL_STATE_PLACEMENTS = [
     pair("docker", "subprocess", "harness-in-docker-with-tool-in-subprocess"),
     pair("subprocess", "docker", "harness-in-subprocess-with-tool-in-docker"),
     pair("modal", "colocated", "harness-in-modal-with-tool-colocated"),
+    pair("e2b", "colocated", "harness-in-e2b-with-tool-colocated"),
 ]
 
 # Shared servers always run in their own runtime (colocation is per-rollout, shared is
@@ -265,6 +284,7 @@ SHARED_TOOL_PLACEMENTS = [
     pair("docker", "docker", "harness-in-docker-with-tool-in-docker"),
     pair("subprocess", "docker", "harness-in-subprocess-with-tool-in-docker"),
     pair("modal", "modal", "harness-in-modal-with-tool-in-modal"),
+    pair("e2b", "e2b", "harness-in-e2b-with-tool-in-e2b"),
 ]
 
 
@@ -318,6 +338,29 @@ async def test_browser_use(run_v1, tmp_path):
     assert trace.reward == 1.0
 
 
+@pytest.mark.e2e
+@pytest.mark.parametrize("harness_runtime", AGENT_USER_RUNTIMES, indirect=True)
+async def test_agent_user_cannot_act_as_root(run_v1, harness_runtime, tmp_path):
+    """A scripted, model-free agent runs as the task's non-root `agent_user`: it can see
+    the secret the root-run setup planted and write its own workspace, but every
+    root-only action (read the secret, write /etc, chmod the secret, signal PID 1) is
+    denied."""
+    (trace,) = await run_v1(
+        "agent-user-v1",
+        harness="agent-user-v1",
+        runtime={"type": harness_runtime},
+        output_dir=tmp_path,
+    )
+    report = trace.info["agent_user_report"]
+    assert report["user"] == "vf-agent"
+    assert report["secret_exists"] == "ok" and report["write_workdir"] == "ok"
+    root_actions = ("read_secret", "write_etc", "chmod_secret", "signal_init")
+    assert {action: report[action] for action in root_actions} == dict.fromkeys(
+        root_actions, "denied"
+    )
+    assert trace.reward == 1.0
+
+
 @pytest.mark.e2e
 @pytest.mark.parametrize("harness_runtime", USER_RUNTIMES, indirect=True)
 async def test_user(run_v1, harness_runtime, tmp_path):
@@ -389,7 +432,9 @@ async def test_acp_resume_with_tool(run_v1, harness, harness_runtime, tmp_path):
     (trace,) = await run_v1(
         "echo-acp-resume-v1",
         harness=harness,
-        runtime={"type": harness_runtime},
+        runtime=harness_runtime
+        if isinstance(harness_runtime, dict)
+        else {"type": harness_runtime},
         output_dir=tmp_path,
         max_turns=8,
         max_tokens=8192,

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/verifiers/v1/rollout.py

@@ -14,6 +14,7 @@ from verifiers.v1.configs.runtime import NetworkPolicyConfig
 from verifiers.v1.errors import (
     HarnessError,
     RolloutError,
+    SandboxError,
     TaskError,
     ToolsetError,
     boundary,
@@ -52,6 +53,39 @@ class RolloutTimeouts:
     """Timeout (in seconds) for the task + harness metrics + scoring hooks."""
 
 
+_HOME_PROBE = (
+    "home=$(awk -F: -v u=\"$1\" '$1 == u { print $6 }' /etc/passwd); "
+    'echo "$home"; test -n "$home" && test -d "$home"'
+)
+
+
+async def agent_runtime(runtime: Runtime, user: str | None) -> Runtime:
+    """The runtime the harness runs on: `runtime` itself, or a view running as `user`
+    with `HOME` set to its home. `user` must exist with a home directory it can write
+    (task authors ship it in the image), and the view must really run as it, so a
+    runtime ignoring the user never runs the agent as root."""
+    if user is None:
+        return runtime
+    lookup = await runtime.run(["sh", "-c", _HOME_PROBE, "sh", user], {})
+    home = lookup.stdout.strip()
+    if not home:
+        raise TaskError(f"agent_user {user!r} does not exist in the image")
+    if lookup.exit_code != 0:
+        raise TaskError(f"agent_user {user!r} has no home directory ({home})")
+    view = runtime.with_user(user)
+    view = view.with_env({**view.env, "HOME": home})
+    probe = await view.run(["sh", "-c", 'id -un; test -w "$HOME" && echo writable'], {})
+    effective, *rest = probe.stdout.split() or [""]
+    if effective != user:
+        raise SandboxError(
+            f"{type(runtime).__name__} ran as {effective!r} instead of agent_user "
+            f"{user!r}; refusing to run the agent"
+        )
+    if rest != ["writable"]:
+        raise TaskError(f"agent_user {user!r} cannot write its home directory ({home})")
+    return view
+
+
 class Rollout:
     """Manages one rollout's lifecycle (open, step, close)."""
 
@@ -341,7 +375,7 @@ class Rollout:
                     self._harness_session = await self.harness.session(
                         self.ctx,
                         self.trace,
-                        runtime,
+                        await agent_runtime(runtime, harness_data.agent_user),
                         self._endpoint,
                         self._secret,
                         self._urls,

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/verifiers/v1/runtimes/__init__.py

@@ -25,6 +25,7 @@ from verifiers.v1.runtimes.docker import (
     PodmanRuntime,
     PodmanRuntimeInfo,
 )
+from verifiers.v1.runtimes.e2b import E2BConfig, E2BRuntime, E2BRuntimeInfo
 from verifiers.v1.runtimes.modal import ModalConfig, ModalRuntime, ModalRuntimeInfo
 from verifiers.v1.runtimes.prime import (
     PrimeConfig,
@@ -44,7 +45,8 @@ RuntimeConfig = Annotated[
     | PodmanConfig
     | ApptainerConfig
     | PrimeConfig
-    | ModalConfig,
+    | ModalConfig
+    | E2BConfig,
     Field(discriminator="type"),
 ]
 
@@ -54,7 +56,8 @@ RuntimeInfo = Annotated[
     | PodmanRuntimeInfo
     | ApptainerRuntimeInfo
     | PrimeRuntimeInfo
-    | ModalRuntimeInfo,
+    | ModalRuntimeInfo
+    | E2BRuntimeInfo,
     Field(discriminator="type"),
 ]
 
@@ -67,6 +70,7 @@ def _runtime_cls(config: RuntimeConfig) -> type[Runtime]:
         "apptainer": ApptainerRuntime,
         "prime": PrimeRuntime,
         "modal": ModalRuntime,
+        "e2b": E2BRuntime,
     }[config.type]
 
 
@@ -109,6 +113,9 @@ __all__ = [
     "DockerConfig",
     "DockerRuntime",
     "DockerRuntimeInfo",
+    "E2BConfig",
+    "E2BRuntime",
+    "E2BRuntimeInfo",
     "ModalConfig",
     "ModalRuntime",
     "ModalRuntimeInfo",

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/verifiers/v1/runtimes/base.py

@@ -136,13 +136,16 @@ class BaseRuntimeInfo(BaseConfig):
 
 
 class Runtime(ABC):
-    __slots__ = ("env",)
+    __slots__ = ("env", "user")
 
     is_local: bool = True
     """Whether this runtime exchanges host-local URLs without a public tunnel. True for
     subprocess and the local container runtimes; remote runtimes override to False and
     use a host `Tunnel` inward plus `expose` outward."""
 
+    supports_user: ClassVar[bool] = False
+    """Whether `with_user` can run this runtime's commands as another existing user."""
+
     scripts_dir: ClassVar[str] = "/tmp/vf-scripts"
     """Digest-keyed PEP 723 scripts inside the runtime. Sandboxes own their `/tmp`;
     the host subprocess runtime overrides this with its per-user cache."""
@@ -159,6 +162,8 @@ class Runtime(ABC):
         # Per-run task values live on the runtime rather than its serializable config/info.
         # Explicit process values (model credentials, proxy settings, etc.) override these.
         self.env: dict[str, str] = {}
+        self.user: str | None = None
+        """Existing user this view runs commands as; None uses the runtime's default."""
         self._uv_interpreters: dict[str, str] = {}
         self._uv_script_locks: dict[str, asyncio.Lock] = {}
         self._mcp_sources: set[str] = set()
@@ -215,6 +220,19 @@ class Runtime(ABC):
         runtime.env = dict(env)
         return runtime
 
+    def with_user(self, user: str | None) -> "Runtime":
+        """Share this physical runtime through a view that runs commands as `user`, an
+        existing user in the box (None keeps the default). Only the view runs as `user`:
+        setup, collection, and grading keep using the original runtime."""
+        if user is not None and not self.supports_user:
+            raise ValueError(
+                f"{type(self).__name__} cannot run commands as another user"
+            )
+        runtime = copy.copy(self)
+        runtime.__dict__ = self.__dict__
+        runtime.user = user
+        return runtime
+
     async def alive(self) -> bool:
         """Whether the box still executes anything. Not every runtime raises when
         the box is gone — some surface it as `exec`'s own non-zero result,

{verifiers-0.3.2.dev167 → verifiers-0.3.2.dev169}/verifiers/v1/runtimes/docker/__init__.py

@@ -70,6 +70,7 @@ control.sendmsg([b"listener"], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.arr
 
 
 class DockerRuntime(ContainerRuntime):
+    supports_user: ClassVar[bool] = True
     engine: ClassVar[str] = "docker"
     """The CLI binary for the shared OCI container operations."""
     info_cls: ClassVar[type[BaseRuntimeInfo]] = DockerRuntimeInfo
@@ -529,6 +530,7 @@ class DockerRuntime(ContainerRuntime):
             "exec",
             *(("-i",) if stdin else ()),
             *(arg for key, value in env.items() for arg in ("--env", f"{key}={value}")),
+            *(("--user", self.user) if self.user is not None else ()),
             "--workdir",
             self.config.workdir,
             self._container,