diff --git a/src/agent_env/bundle/plan.py b/src/agent_env/bundle/plan.py index fe8e76278..8bde4f3a3 100644 --- a/src/agent_env/bundle/plan.py +++ b/src/agent_env/bundle/plan.py @@ -896,7 +896,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity website as its backend's and frontend's. No two of a multi's envs may name one container, and a provider other than the core's, which gives a multi one env card, can't tell an MCP server and a website of one name apart. Nor may two of its websites claim one name. A computer runs on a sandbox of its own, which the gateway - knows by its name alone, and serves its tools under it (``_multi_computers.name_problems``).""" + knows by its name alone, and serves its tools under it (``_multi_computers.name_problems``); its apps' names + are no other child env's, since loads and snapshots find an environment by its name.""" for key in sorted(closure, key=self.rank.__getitem__): source = self.nodes[key] if isinstance(source, BundleImage) or source.entry.kind is not BundleKind.ENV: @@ -907,6 +908,7 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity taken: dict[str, str] = {} # each container a child runs as, by the field naming the child named: dict[str, set[str]] = {} # the environment_names of each list's envs computers: list[str] = [] # the computers' environment_names, in order + apps: dict[str, set[str]] = {} # each computer's apps' environment_names, when they're known claimed = [sites.Claim(domain, sites.SYNTHETIC, ref.where) for ref in source.references if ref.where.startswith("website_envs[") for domain in dict.fromkeys(self._domains(ref, store_latest))] @@ -921,6 +923,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity named.setdefault(group, set()).add(name) if group == "computer_envs": computers.append(name) + if (held := self._server_names(ref, store_latest)) is not None: + apps[name] = held - {name} continue containers = [name] if group == "mcp_server_envs" else [ f"{name}-{AGENT_ENV_WEBSITE_BACKEND_SUFFIX}", f"{name}-{AGENT_ENV_WEBSITE_FRONTEND_SUFFIX}"] @@ -932,6 +936,8 @@ def _check_multi_names(self, closure: set[_Key], store_latest: dict[tuple[Entity taken.update(dict.fromkeys(containers, ref.where)) self.problems += [f"{where}: computer_envs: {problem}" for problem in _multi_computers.name_problems( computers, mcp_servers=named.get("mcp_server_envs", ()), websites=named.get("website_envs", ()))] + self.problems += [f"{where}: computer_envs: {problem}" for problem in _multi_computers.app_name_problems( + apps, [*named.get("mcp_server_envs", ()), *named.get("website_envs", ()), *computers])] provider_type = source.config.get("env_provider_type", EnvironmentGatewayProvider.type) try: provider = _env_provider_class(provider_type) @@ -1012,13 +1018,19 @@ def _check_loaded_environments(self, closure: set[_Key], def _server_names(self, ref: Reference, store_latest: dict[tuple[EntityKind, str], int] | None) -> set[str] | None: """The environment_names of the servers the env ``ref`` names runs: an MCP server's or a website's own, each - of a multi's envs', or a computer's own and each of its apps'. None when they aren't all known.""" + of a multi's envs', its computers' apps' too, or a computer's own and each of its apps'. None when they aren't + all known.""" if isinstance(ref.local, BundleEntry): cls = get_env_registry().get(ref.local.type) children = self.nodes[_key(ref.local)].references if cls is not None and issubclass(cls, MultiEnv): - names = {self._environment_name(child, store_latest) for child in children - if child.kind is EntityKind.ENV} + names = set() + for child in children: + if child.kind is not EntityKind.ENV: + continue + held = (self._server_names(child, store_latest) if child.where.startswith("computer_envs[") else + {self._environment_name(child, store_latest)}) + names |= held if held is not None else {None} else: names = {self.accepted.get(_key(ref.local), {}).get("environment_name")} if cls is not None and issubclass(cls, ComputerEnv): @@ -1032,7 +1044,9 @@ def _server_names(self, ref: Reference, store_latest: dict[tuple[EntityKind, str except (NotFoundError, ValueError, KeyError, TypeError): return None # reported by the store ref check if isinstance(env, MultiEnv): - return {child.environment_name for child in [*env.mcp_server_envs, *env.website_envs]} + return {*(child.environment_name for child in [*env.mcp_server_envs, *env.website_envs]), + *(name for computer in env.computer_envs + for name in (computer.environment_name, *(app.environment_name for app in computer.composed_apps())))} if isinstance(env, ComputerEnv): return {env.environment_name, *(app.environment_name for app in env.composed_apps())} name = getattr(env, "environment_name", None) diff --git a/src/agent_env/env/envs/_deployment.py b/src/agent_env/env/envs/_deployment.py index 755d78261..428c88528 100644 --- a/src/agent_env/env/envs/_deployment.py +++ b/src/agent_env/env/envs/_deployment.py @@ -1,5 +1,6 @@ """The env side of the environment-provider contract: deploying an env through its provider, the options a provider takes, -the checks on a plugin's record, loading into a deployment a plugin's provider made, and closing a deployment.""" +the checks on a plugin's record, loading into a deployment a plugin's provider made, emptying a server's data, and closing +a deployment.""" from __future__ import annotations @@ -10,9 +11,11 @@ from collections.abc import Awaitable, Callable from typing import TYPE_CHECKING, Optional +import httpx from agentenv_protocol import DATA_OBJECTS_EXTENSION_URI, METHOD_ADD, METHOD_RESET, RPC_PATH, FilePart, client as protocol_v1 from agent_env.env import legacy_protocol from agent_env.env.env import DeployedSandboxEnv, gateway_url_of +from agent_env.env.gateway.constants import DATA_PLANE_LOAD_TIMEOUT_S from agent_env.env.store import register_env_instance from agent_env.store.base import ObjectNotFoundError from agent_env.utils.paths import validate_file_name @@ -142,6 +145,43 @@ async def load_by_signed_url(env: MCPServerEnv | WebsiteEnv, environment_artifac await protocol_v1.add_data(base_url, file_parts(environment_artifact, files, urls), timeout=timeout) +async def reset_server_data(env: MCPServerEnv | WebsiteEnv, *, mcp: bool) -> bool: + """Empty what loads put into ``env``, an MCP server or with ``mcp=False`` a website, as each load does before it adds: + through ``data/reset``, or an older server's ``/api/reset``, or else its ``_reset`` tool, which with no seed + puts back the data the server boots with; then, behind a gateway of ours, its changelog started afresh, as after a + load. ``env`` is attached to its deployment, which may be a MultiEnv's. False, with nothing sent, for one serving no + reset, which takes no load either: a card declaring operations without ``data/reset``, a plugin's card offering it + no data plane, or an older server answering 404 that offers no ``_reset`` tool.""" + name = env.environment_name + if env._deployed is None and env._gateway_url is None: + raise RuntimeError("Environment not deployed - call deploy() first") + builtin = as_builtin(env._env_provider) + base_url = await legacy_protocol.v1_base_url(env._deployed, env._gateway_url, name, mcp=mcp) + if base_url is not None: + child = env._deployed.child_env(name, mcp=mcp) if env._deployed is not None and env._deployed.environment_card else None + if child is not None and child.serves(METHOD_RESET) is False: + return False + await protocol_v1.reset_data(base_url, timeout=DATA_PLANE_LOAD_TIMEOUT_S) + elif builtin is None: + return False + else: + try: + await legacy_protocol.reset_via_rest(legacy_protocol.environment_base_url(env._gateway_url, name, mcp=mcp), + timeout=60) + except httpx.HTTPStatusError as e: + if e.response.status_code != 404: + raise + mcp_url = f"{env._gateway_url.rstrip('/')}/mcp" + if not (mcp and await legacy_protocol.offers_tool(mcp_url, f"{name}_reset")): + return False + if (answer := await legacy_protocol.reset_via_mcp_tool(mcp_url, name)).isError: + said = "".join(part.text for part in answer.content if hasattr(part, "text")) + raise RuntimeError(f"MCP server '{name}': its {name}_reset tool failed: {said}") from None + if builtin is not None: + await builtin.install_changelog_triggers(name) + return True + + def file_parts(environment_artifact: EnvironmentArtifact, files: dict[str, FileArtifact], uris: dict[str, str]) -> list[FilePart]: """The parts ``data/add`` takes ``environment_artifact``'s ``files`` as, each fetched from its uri in ``uris``: one file as the one part it has always been sent as, each of several with its path in the data-objects marker.""" diff --git a/src/agent_env/env/envs/_multi_computers.py b/src/agent_env/env/envs/_multi_computers.py index 907f0acba..eda519f88 100644 --- a/src/agent_env/env/envs/_multi_computers.py +++ b/src/agent_env/env/envs/_multi_computers.py @@ -7,8 +7,8 @@ import dataclasses import logging from collections import Counter -from collections.abc import Awaitable, Callable, Iterable -from typing import TYPE_CHECKING, Optional +from collections.abc import Awaitable, Callable, Iterable, Mapping +from typing import TYPE_CHECKING, Any, Optional from agentenv_protocol.computer import tool_prefix_problem @@ -17,6 +17,7 @@ from agent_env.providers.sandbox_providers.sandbox_provider import build_sandbox_provider, get_env_sandbox_provider if TYPE_CHECKING: + from agent_env.artifact import EnvironmentArtifact from agent_env.attribution import Attribution from agent_env.env.envs.computer.env import ComputerEnv @@ -40,6 +41,18 @@ def name_problems(computers: Iterable[str], *, mcp_servers: Iterable[str] = (), return problems +def app_name_problems(apps: Mapping[str, Iterable[str]], others: Iterable[str]) -> list[str]: + """What's wrong with the names of each computer's apps, ``apps`` by the computer's name, beside ``others``, every + other name the multi env's child envs go by: loads and snapshots find an environment by its name, so an app's must + be no other's.""" + apps = {computer: list(dict.fromkeys(names)) for computer, names in apps.items()} + taken = Counter(set(others)) + for names in apps.values(): + taken.update(names) + return [f"app {name!r} of computer {computer!r} has the name of another of its child envs, and loads and snapshots " + "find an environment by its name" for computer, names in apps.items() for name in names if taken[name] > 1] + + def deploy_options(entry: Optional[dict], sandbox_type: str | None) -> dict: """A computer's deploy options from its child_envs entry: on ``sandbox_type``, the multi env's, unless it names one.""" return {"sandbox_type": sandbox_type, **(entry or {})} @@ -88,6 +101,23 @@ def commit(self) -> None: (earlier, replaced), self._earlier = self._earlier, None self._replaced = [*replaced, *(earlier if self.envs is not earlier else [])] + def holding(self, environment_name: str) -> Optional[ComputerEnv]: + """The computer a load of ``environment_name`` reaches: the one of that name, or with an app of it.""" + return next((env for env in self.envs if env.holds(environment_name)), None) + + async def load(self, environments: list[EnvironmentArtifact]) -> None: + """Load each computer's of ``environments`` into it, in its own order, the computers at once (``each``).""" + await each(self._owner, "load", [(f"computer {env.environment_name!r}", env.load_environments(held)) + for env in self.envs + if (held := [e for e in environments if env.holds(e.environment_name)])]) + + def resets(self, deployed: DeployedEnv) -> list[tuple[str, Awaitable[None]]]: + """Each computer ``deployed``, the multi env's record, holds, by name, with its reset from its own record, as it + resets alone; none is awaited yet.""" + records = getattr(deployed, "child_envs", None) or {} + return [(env.environment_name, env.reset(DeployedEnv.from_dict(records[env.environment_name]))) + for env in self.envs if env.environment_name in records] + def deployer(self, child_envs: Optional[dict], *, sandbox_type: str | None, ttl_seconds: int, attribution: Optional[Attribution]) -> Callable[[Optional[str]], Awaitable[list[ExternalChild]]]: """The gateway's ``children``: every computer deployed as its child_envs entry says, its tools served under its @@ -142,3 +172,15 @@ async def close(self) -> None: logger.warning(f"multi env '{self._owner}': failed to close computer {env.environment_name!r}: {result!r}") elif isinstance(result, BaseException): raise result + + +async def each(owner: str, what: str, calls: list[tuple[str, Awaitable[Any]]]) -> list[Any]: + """Await ``calls``, each a child env's under its label, at once, and once all have ended, what each returned; or, + when any failed to ``what``, a RuntimeError of the multi env ``owner`` naming each that did.""" + results = await asyncio.gather(*(call for _, call in calls), return_exceptions=True) + if interrupted := next((r for r in results if isinstance(r, BaseException) and not isinstance(r, Exception)), None): + raise interrupted + if failed := [(child, result) for (child, _), result in zip(calls, results) if isinstance(result, Exception)]: + raise RuntimeError(f"multi env '{owner}': " + "; ".join(f"{child} failed to {what}: {error!r}" + for child, error in failed)) from failed[0][1] + return results diff --git a/src/agent_env/env/envs/computer/env.py b/src/agent_env/env/envs/computer/env.py index 4b039e9c8..010b86b3d 100644 --- a/src/agent_env/env/envs/computer/env.py +++ b/src/agent_env/env/envs/computer/env.py @@ -385,7 +385,16 @@ async def load_environment_universe_artifact(self, environment_universe_artifact if environment.environment_name not in names]: logger.warning(f"[{self.id}] loading only {[environment.environment_name for environment in known]} from " f"'{environment_universe_artifact.id}'; leaving out {others}") - await self._load(sorted(known, key=lambda environment: environment.environment_name != self.computer_name)) + await self.load_environments(known) + + def holds(self, environment_name: str) -> bool: + """Whether a load reaches ``environment_name`` in this computer: its own, or one of its apps'.""" + return environment_name in self._environment_names() + + async def load_environments(self, environments: list[EnvironmentArtifact]) -> None: + """Load ``environments``, each named after the computer or one of its apps: its own first, then its apps', so + what an app keeps ends as its own export has it.""" + await self._load(sorted(environments, key=lambda environment: environment.environment_name != self.computer_name)) async def reset(self, deployed: DeployedEnv) -> None: """Return the computer to boot state: its recordings ended, its container replaced with a fresh one of the same diff --git a/src/agent_env/env/envs/mcp_server.py b/src/agent_env/env/envs/mcp_server.py index 2f950f77a..bb959deb3 100644 --- a/src/agent_env/env/envs/mcp_server.py +++ b/src/agent_env/env/envs/mcp_server.py @@ -21,7 +21,8 @@ from agent_env.env import legacy_protocol from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, staged_paths, + file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, reset_server_data, + staged_paths, ) from agent_env.env.gateway import GatewayMode from agent_env.providers.sandbox_providers.sandbox import VmSandbox @@ -136,6 +137,12 @@ async def from_deployed_env(cls, deployed: DeployedEnv) -> MCPServerEnv: env._deployed = deployed return env + async def reset(self, deployed: DeployedEnv) -> None: + """Empty what loads put into the server, attached to ``deployed`` as a load is, so a task loads it again after; + NotImplementedError for one serving no reset, which takes no load either.""" + if not await reset_server_data(await type(self).from_deployed_env(deployed), mcp=True): + raise NotImplementedError(f"MCP server '{self.environment_name}' serves no reset") + async def close(self) -> None: await close_replaced(self) if self._env_provider is not None: diff --git a/src/agent_env/env/envs/multi_env.py b/src/agent_env/env/envs/multi_env.py index df7a769a3..fe5b4d27c 100644 --- a/src/agent_env/env/envs/multi_env.py +++ b/src/agent_env/env/envs/multi_env.py @@ -40,8 +40,9 @@ def _snapshot_after_load_default() -> bool: from agent_env.env.gateway import GatewayMode from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - plugin_provider_like_a_builtin, provider_or_class, + plugin_provider_like_a_builtin, provider_or_class, reset_server_data, ) +from agent_env.env import store as env_store from agent_env.env.envs import _multi_computers from agent_env.env.envs.computer import COMPUTER_ENV_TYPE from agent_env.env.envs.computer.utils import sites @@ -102,9 +103,14 @@ def __init__(self, id: str, version: Optional[int], mcp_server_envs: list[MCPSer for name in dict.fromkeys(env.domains)]): raise sites.SiteConflict(f"multi env {id!r}: its websites claim names twice: {'; '.join(conflicts)}") self._computers = _multi_computers.Computers(computer_envs or [], owner=id) - if problems := _multi_computers.name_problems([env.environment_name for env in self.computer_envs], - mcp_servers=[env.environment_name for env in self.mcp_server_envs], - websites=[env.environment_name for env in self.website_envs]): + servers = [env.environment_name for env in (*self.mcp_server_envs, *self.website_envs)] + computers = [env.environment_name for env in self.computer_envs] + if problems := [*_multi_computers.name_problems(computers, + mcp_servers=[env.environment_name for env in self.mcp_server_envs], + websites=[env.environment_name for env in self.website_envs]), + *_multi_computers.app_name_problems({env.environment_name: [app.environment_name + for app in env.composed_apps()] + for env in self.computer_envs}, [*servers, *computers])]: raise ValueError(f"multi env {id!r}: {'; '.join(problems)}") self._sandbox = None self._gateway_url = None @@ -259,6 +265,15 @@ def child_envs_refusal(self, child_envs: Optional[dict], *, sandbox_type: str | @classmethod async def from_deployed_env(cls, deployed: DeployedEnv) -> MultiEnv: + env = await cls._attached(deployed) + if env.computer_envs: + await env._computers.reattach(deployed) + return env + + @classmethod + async def _attached(cls, deployed: DeployedEnv) -> MultiEnv: + """The multi env ``deployed`` records, attached to it as its loads are: its gateway reattached, and its MCP + servers and websites handed the provider and the record; its computers aren't reattached.""" env = Env.get(deployed.env_id, deployed.env_version) if not isinstance(env, MultiEnv): raise TypeError(f"Expected MultiEnv, got {type(env).__name__}") @@ -273,8 +288,6 @@ async def from_deployed_env(cls, deployed: DeployedEnv) -> MultiEnv: _hand_record_to_child_envs(env, deployed) env._instance_id = deployed.instance_id env._mcp_server_name = deployed.mcp_server_name - if env.computer_envs: - await env._computers.reattach(deployed) return env async def load_environment_artifact(self, environment_artifact: EnvironmentArtifact) -> None: @@ -290,6 +303,9 @@ async def load_environment_artifact(self, environment_artifact: EnvironmentArtif if env.environment_name == environment_artifact.environment_name: await env.load_environment_artifact(environment_artifact) return + if (computer := self._computers.holding(environment_artifact.environment_name)) is not None: + await computer.load_environment_artifact(environment_artifact) + return logger.warning(f"No env with environment_name '{environment_artifact.environment_name}' — skipping") async def load_environment_universe_artifact( @@ -301,6 +317,7 @@ async def load_environment_universe_artifact( A snapshot restore swaps a pre-ingested servicedb image; a miss re-ingests every service over HTTP under a fixed 600s per-service cap. + Either way each computer's environments then load into it, in its own order. Restore is NOT reliably faster. Measured on a 13-service / ~8.7GB universe: restore ~4min (an image pull plus recreating every service container) versus @@ -343,6 +360,9 @@ async def load_environment_universe_artifact( env_fingerprint=env_fingerprint, ) if can_restore else None restored_from_snapshot = False + # The universe's environments, read at most once, and only for a load that needs them: a restore reads none + # unless the multi env has computers to load. + environments: Optional[list[EnvironmentArtifact]] = None snapshot_baked: bool | None = None snapshot_bake_error: str | None = None @@ -352,16 +372,14 @@ async def load_environment_universe_artifact( restored_from_snapshot = True # A restore swaps the whole database at once, so per-service resume state from # any earlier partial re-ingest no longer describes anything real. - if self._instance_id: - try: - from agent_env.env.store import get_env_instance_store - get_env_instance_store().clear_loaded_environments(self._instance_id) - except Exception as e: # noqa: BLE001 - logger.warning("Could not clear resume state after a snapshot restore: %s", e) + _forget_loaded_environments(self._instance_id) else: import asyncio import time - environment_artifacts = environment_universe_artifact.get_environment_artifacts() + # The services' alone: the computers' load after them, in each computer's own order. + environments = environment_universe_artifact.get_environment_artifacts() + environment_artifacts = [artifact for artifact in environments + if self._computers.holding(artifact.environment_name) is None] total = len(environment_artifacts) # WARNING, not info: this is the path that can FAIL. Every service is # re-ingested over HTTP under a fixed per-service timeout, and one service @@ -450,9 +468,13 @@ async def _load_one(idx: int, artifact): for i, name, e in failed ) ) + if self.computer_envs: + # Every time, never skipped as a resumed service is: the changelog a resume reads doesn't see a computer's + # files. + await self._computers.load(environments if environments is not None + else environment_universe_artifact.get_environment_artifacts()) if self._instance_id: - from agent_env.env.store import update_env_instance_environment_universe - update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) + env_store.update_env_instance_environment_universe(self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version) # Bake the snapshot that makes the NEXT load of this (images, universe) pair an # image swap. Deliberately placed here: after the universe stamp, which @@ -516,9 +538,8 @@ async def _resumable_environments(self, environment_universe_artifact, total: in return set() try: from agent_env.env.snapshot_store import _check_changelog_empty - from agent_env.env.store import get_env_instance_store - recorded = set(get_env_instance_store().get_loaded_environments( + recorded = set(env_store.get_env_instance_store().get_loaded_environments( self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version, )) if not recorded: @@ -550,9 +571,7 @@ def _record_loaded_environment(self, environment_universe_artifact, environment_ if not self._instance_id: return try: - from agent_env.env.store import get_env_instance_store - - get_env_instance_store().record_loaded_environment( + env_store.get_env_instance_store().record_loaded_environment( self._instance_id, environment_universe_artifact.id, environment_universe_artifact.version, environment_name, ) @@ -867,6 +886,28 @@ async def validate_universe_compatibility(self, universe_artifact_id: str, unive # (the final task step), so it persists wherever the Task runs — not only via this method. return context.instance_id + async def reset(self, deployed: DeployedEnv) -> None: + """Reset every child env at once, each as it resets alone: a computer reboots from its own record and gets its + ``tools`` again, and an MCP server or website is emptied of what loads put in, so a task loads again after; one + serving no reset takes no load, and stays as it is. A child that fails to reset fails the reset, each such one + named, once the others have reset. Before any server is emptied, which services the instance's loads put in is + forgotten, so the next load puts each in again rather than resuming past one; a reset that can't forget it + empties nothing.""" + services = self + if self.mcp_server_envs or self.website_envs: + services = await type(self)._attached(deployed) + if deployed.instance_id: + env_store.get_env_instance_store().clear_loaded_environments(deployed.instance_id) + resets = [*((f"computer {name!r}", call) for name, call in self._computers.resets(deployed)), + *((f"MCP server {env.environment_name!r}", reset_server_data(env, mcp=True)) + for env in services.mcp_server_envs), + *((f"website {env.environment_name!r}", reset_server_data(env, mcp=False)) + for env in services.website_envs)] + results = await _multi_computers.each(self.id, "reset", resets) + for (child, _), result in zip(resets, results): + if result is False: + logger.info(f"multi env '{self.id}': {child} serves no reset and takes no load, so it stays as it is") + async def close(self) -> None: await self._computers.close() await close_replaced(self) @@ -884,6 +925,18 @@ async def close(self) -> None: self._sandbox = None +def _forget_loaded_environments(instance_id: Optional[str]) -> None: + """Forget which services the instance's loads put in, so its next load puts each in again rather than resuming; + best-effort, since only a resumed load reads it.""" + if not instance_id: + return + try: + env_store.get_env_instance_store().clear_loaded_environments(instance_id) + except Exception as e: # noqa: BLE001 + logger.warning(f"Could not forget which services instance {instance_id!r} loaded; a resumed load may skip " + f"one: {e}") + + def _hand_provider_to_child_envs(env: MultiEnv) -> None: """Point each child env at the MultiEnv's deployment: the provider and URL its loads use, and behind our gateway the sandbox they stage into. A plugin's provider leaves them no sandbox, so they load through the record's card.""" diff --git a/src/agent_env/env/envs/website.py b/src/agent_env/env/envs/website.py index 474a2a9a6..62ceb925e 100644 --- a/src/agent_env/env/envs/website.py +++ b/src/agent_env/env/envs/website.py @@ -27,7 +27,8 @@ from agent_env.env import legacy_protocol from agent_env.env.envs._deployment import ( as_builtin, builtin_provider_for, close_deployed, close_replaced, deploy_refusal, deploy_through_provider, host_staging_refusal, - file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, staged_paths, + file_parts, legacy_load_file, load_by_signed_url, plugin_provider_like_a_builtin, provider_or_class, reset_server_data, + staged_paths, ) from agent_env.env.gateway import GatewayMode from agent_env.attribution import Attribution @@ -289,6 +290,12 @@ async def _load_environment_artifact_legacy(self, file_artifact) -> None: ) raise + async def reset(self, deployed: DeployedEnv) -> None: + """Empty what loads put into the website, attached to ``deployed`` as a load is, so a task loads it again after; + NotImplementedError for one serving no reset, which takes no load either.""" + if not await reset_server_data(await type(self).from_deployed_env(deployed), mcp=False): + raise NotImplementedError(f"website '{self.environment_name}' serves no reset") + async def close(self) -> None: await close_replaced(self) if self._env_provider is not None: diff --git a/src/agent_env/env/legacy_protocol.py b/src/agent_env/env/legacy_protocol.py index df302b5e9..c914e51cd 100644 --- a/src/agent_env/env/legacy_protocol.py +++ b/src/agent_env/env/legacy_protocol.py @@ -15,6 +15,9 @@ import httpx from agentenv_protocol import METHOD_GET, DataPart, client as protocol_v1 +from mcp import ClientSession +from mcp.types import CallToolResult +from mcp.client.streamable_http import streamable_http_client if TYPE_CHECKING: from agent_env.env.env import DeployedEnv @@ -42,18 +45,27 @@ class BackingServer: One the env's card lists (``card_servers``) carries that ``child`` and the ``address`` its paths resolve against. One the card lists none for, a server serving no card, carries the ``address`` alone: it has no card, and none is read for it. One named by the env definition of a record whose card can't be read carries neither, so its card is - read live at its gateway path, ``/svc/mcp-{name}`` or a website's ``/svc/{name}`` (``server_card``).""" + read live at its gateway path, ``/svc/mcp-{name}`` or a website's ``/svc/{name}`` (``server_card``). One on a + sandbox of its own, a multi env's computer or one of its apps, carries the ``record`` of the env it runs in, whose + card lists it and whose control token its routes take, which the env's own doesn't.""" environment_name: str mcp: bool = True child: Optional[protocol_v1.ChildEnv] = None address: Optional[str] = None + # Not compared: a record isn't hashable, and a server's address already tells it apart. + record: Optional[DeployedEnv] = dataclasses.field(default=None, compare=False) @property def card(self) -> Optional[dict]: """The server's card as the env's card lists it, or None.""" return self.child.card if self.child is not None else None + def owner(self, deployed: DeployedEnv) -> DeployedEnv: + """The record whose control token a call to the server takes: its own ``record``, a multi env's computer's or + one of its apps', else ``deployed``, the record of the env it was listed for.""" + return self.record or deployed + def definition_servers(env: Any) -> list[BackingServer]: """The servers an env definition names: a MultiEnv's MCP servers then its websites, a WebsiteEnv's website, or @@ -113,15 +125,36 @@ async def backing_servers(deployed: Optional[DeployedEnv], gateway_url: Optional elif deployed is not None: why = "its record has no card URL" named = definition_servers(env) + # A record's computers are its own deployment's: none when the gateway asked is another's. + own = ((getattr(deployed, "child_envs", None) or {}) + if deployed is not None and (gateway is None or (gateway_url_of(deployed) or "").rstrip("/") == gateway) else {}) if not isinstance(card, dict): logger.info(f"env {getattr(env, 'id', None)!r}: {why}, so its servers are the ones its definition names, " f"each read live at its gateway path: {[(s.environment_name, s.mcp) for s in named]}") - return named + return _on_own_sandboxes(named, own) servers = card_servers(card, address) if not gateway: - return servers + return _on_own_sandboxes(servers, own) listed = {(s.environment_name, s.mcp) for s in servers} - return servers + [dataclasses.replace(s, address=address) for s in named if (s.environment_name, s.mcp) not in listed] + return _on_own_sandboxes(servers + [dataclasses.replace(s, address=address) for s in named + if (s.environment_name, s.mcp) not in listed], own) + + +def _on_own_sandboxes(servers: list[BackingServer], child_envs: dict[str, dict]) -> list[BackingServer]: + """``servers``, each child env on a sandbox of its own (``DeployedGatewayEnv.child_envs``, a multi env's computers) + listed from its own record instead of as the gateway fronts it: its card's servers at its address, each carrying the + record, whose control token the gateway doesn't send. One whose record keeps no card is left out, and logged.""" + from agent_env.env.env import DeployedEnv + + own = [] + for name, data in child_envs.items(): + record = DeployedEnv.from_dict(data) + if not record.environment_card or not record.environment_url: + logger.warning(f"child env {name!r}: its record keeps no card, so none of its servers is listed") + continue + own += [dataclasses.replace(server, record=record) + for server in card_servers(record.environment_card, record.environment_url)] + return [server for server in servers if server.environment_name not in child_envs] + own async def server_card(server: BackingServer, gateway_url: Optional[str], timeout: int = 10) -> tuple[Optional[str], Optional[dict]]: @@ -230,16 +263,29 @@ async def service_state(deployed: Optional[DeployedEnv], gateway_url: Optional[s return await _export_state_at(base_url, timeout=EXPORT_STATE_TIMEOUT_SECONDS, verify=True) +async def offers_tool(mcp_url: str, name: str) -> bool: + """Whether the MCP endpoint at ``mcp_url`` lists the tool ``name``, on any page of its tools.""" + async with streamable_http_client(mcp_url) as (read_stream, write_stream, _): + async with ClientSession(read_stream, write_stream) as session: + await session.initialize() + cursor = None + while True: + page = await session.list_tools(cursor) + if any(tool.name == name for tool in page.tools): + return True + if not (cursor := page.nextCursor): + return False + + async def reset_via_mcp_tool( mcp_url: str, environment_name: str, - mock_data_path: str, + mock_data_path: Optional[str] = None, max_retries: int = DEFAULT_MCP_MAX_RETRIES, -) -> None: - """Call the ``{environment_name}_reset`` MCP tool, retrying on transient failures.""" - from mcp import ClientSession - from mcp.client.streamable_http import streamable_http_client - +) -> CallToolResult: + """Call the ``{environment_name}_reset`` MCP tool, retrying on transient failures; what it answered. With + ``mock_data_path``, the seed it loads; with none, an older server's tool puts back the data it boots with.""" + arguments = {} if mock_data_path is None else {"mock_data_path": mock_data_path} for attempt in range(max_retries): reset_done = False try: @@ -247,7 +293,7 @@ async def reset_via_mcp_tool( async with ClientSession(read_stream, write_stream) as session: await session.initialize() reset_tool_name = f"{environment_name}_reset" - result = await session.call_tool(reset_tool_name, {"mock_data_path": mock_data_path}) + result = await session.call_tool(reset_tool_name, arguments) result_text = "".join(c.text for c in result.content if hasattr(c, "text")) logger.info(f"load_environment_artifact: {reset_tool_name} returned: {result_text}") reset_done = True @@ -268,6 +314,7 @@ async def reset_via_mcp_tool( raise else: break + return result async def reset( diff --git a/src/agent_env/task_step/task_steps/apply_server_config.py b/src/agent_env/task_step/task_steps/apply_server_config.py index 91cc24167..efe0444c9 100644 --- a/src/agent_env/task_step/task_steps/apply_server_config.py +++ b/src/agent_env/task_step/task_steps/apply_server_config.py @@ -143,8 +143,8 @@ async def _expand_directives(self, deployed) -> list[tuple[ConfigDirective, Opti skipped, as under ``tolerate_unadvertised``, when the website has no card or doesn't advertise the URI, so a website the task didn't name never fails it. A named directive, and every MCP server, stays strict; a named one targets the server of that name, the MCP server when a website shares it, as a MultiEnv's load does, or, without - a broadcast to list them, is looked up by name (None).""" - if not any(d.service == self._BROADCAST for d in self.directives): + a broadcast or a computer of a multi env to list them, is looked up by name (None).""" + if not any(d.service == self._BROADCAST for d in self.directives) and not getattr(deployed, "child_envs", None): return [(d, None, False) for d in self.directives] from agent_env.env import legacy_protocol @@ -257,9 +257,10 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: f"{directive.service!r} (env={self.env_id}). " f"Advertised: {[e.get('uri') for e in (card.get('capabilities') or {}).get('extensions') or []]}" ) + owner = server.owner(deployed) if server is not None else deployed result = await protocol_v1.invoke_extension( base_url, card, directive.uri, params=directive.args, - timeout=self.timeout_seconds, headers=deployed.control_headers, + timeout=self.timeout_seconds, headers=owner.control_headers, ) except ApplyServerConfigError: raise diff --git a/src/agent_env/task_step/task_steps/reset_env.py b/src/agent_env/task_step/task_steps/reset_env.py index 88059fdde..79cff0deb 100644 --- a/src/agent_env/task_step/task_steps/reset_env.py +++ b/src/agent_env/task_step/task_steps/reset_env.py @@ -2,8 +2,9 @@ Env-agnostic: looks up the deployed env in context and calls its ``reset()``. Best-effort by default — a reset failure (including an env that doesn't support -it) is logged and the run continues. Place right before prompt_agent in a -warm-reuse task. +it) is logged and the run continues. A reset empties what loads put in (a +computer reboots, an MCP server or website is emptied), so in a warm-reuse task +place it before the load that seeds the next attempt, then prompt_agent. """ from __future__ import annotations diff --git a/src/agent_env/task_step/task_steps/snapshot_env.py b/src/agent_env/task_step/task_steps/snapshot_env.py index abb5573f3..d42d70943 100644 --- a/src/agent_env/task_step/task_steps/snapshot_env.py +++ b/src/agent_env/task_step/task_steps/snapshot_env.py @@ -694,8 +694,8 @@ async def export_one(server: BackingServer): try: result = await cls._export_environment_to_file( gateway, environment_name, tmp_path, export_timeout_seconds, - deployed=card_record, data_get_params=(data_get_params or {}).get(environment_name), - server=server, **website, + deployed=server.owner(card_record), + data_get_params=(data_get_params or {}).get(environment_name), server=server, **website, ) except httpx.HTTPStatusError as e: body_snippet = "" diff --git a/src/agent_env/task_step/task_steps/sync_env_clock.py b/src/agent_env/task_step/task_steps/sync_env_clock.py index 8ae463f56..040c958c2 100644 --- a/src/agent_env/task_step/task_steps/sync_env_clock.py +++ b/src/agent_env/task_step/task_steps/sync_env_clock.py @@ -137,8 +137,9 @@ async def execute(self, context: TaskStepContext) -> TaskStepContext: synced, skipped = [], [] for server in await self._backing_servers(deployed): service = server.environment_name - outcome = await self._sync_one(deployed, gateway_url_of(deployed), service, env_get_time_url, mcp=server.mcp, - tolerate=self.tolerate_missing_sync_time or not server.mcp, server=server) + outcome = await self._sync_one(server.owner(deployed), gateway_url_of(deployed), service, env_get_time_url, + mcp=server.mcp, tolerate=self.tolerate_missing_sync_time or not server.mcp, + server=server) entry = {"service": service, "environment": service, **({} if server.mcp else {"website": True}), **outcome} (synced if outcome.get("synced") else skipped).append(entry) diff --git a/tst/integration/computer/multi_env_computers_test.py b/tst/integration/computer/multi_env_computers_test.py index 150f2093f..e349ee2b9 100644 --- a/tst/integration/computer/multi_env_computers_test.py +++ b/tst/integration/computer/multi_env_computers_test.py @@ -21,8 +21,11 @@ from mcp import ClientSession from mcp.client.streamable_http import streamable_http_client +from agent_env.artifact import EnvironmentArtifact, EnvironmentUniverseArtifact, FileArtifact from agent_env.env import Env +from agent_env.env.env import DeployedEnv from agent_env.env.envs.computer.env import COMPUTER_TOOLS, ComputerEnv +from agent_env.env.envs.computer.utils import inside from agent_env.env.envs.mcp_server import MCPServerEnv from agent_env.env.envs.multi_env import MultiEnv from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider @@ -31,7 +34,10 @@ from agent_env.task.teardown import teardown_run from agent_env.task_step.context import TaskStepContext from agent_env.task_step.task_steps.deploy_env import DeployEnvTaskStep -from tst.integration.env.envs.server_env_local_test import _put_items_image +from agent_env.task_step.task_steps.load_artifact import LoadArtifactTaskStep +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep +from agent_env.task_step.task_steps.snapshot_env import SnapshotEnvTaskStep +from tst.integration.env.envs.server_env_local_test import _items_artifact, _put_items_image from tst.integration.store.local_parallel_deploy_test import _docker, _seed_bootstrap_envs pytestmark = [pytest.mark.integration, pytest.mark.int_test_slow] @@ -84,6 +90,30 @@ async def _answers(deployed, tools: list[str], *, until: bool = True, tries: int return answered +def _universe(uid: str, files: dict[str, bytes]) -> EnvironmentUniverseArtifact: + """The items server's two items, and the desktop's ``files`` by their paths under its user's home.""" + desktop = EnvironmentArtifact.put(id=f"office-desktop-{uid}", environment_name="desktop", file_artifacts={ + path: FileArtifact.put_bytes(id=f"office-desktop-{uid}-{index}", description="multi env computers e2e", + filename=path.rsplit("/", 1)[-1], content=content, content_type="text/plain") + for index, (path, content) in enumerate(files.items())}) + return EnvironmentUniverseArtifact.put(id=f"office-world-{uid}", environment_artifacts=[_items_artifact(uid), desktop]) + + +def _snapshotted(context: TaskStepContext, step: str) -> dict[str, dict[str, bytes]]: + """Each environment the snapshot ``step`` kept, with its files by their paths.""" + kept = context.metadata["env_snapshotted_universes"][step] + universe = EnvironmentUniverseArtifact.get(kept["id"], version=kept["version"]) + return {environment.environment_name: {path: file.load() for path, file in environment.get_file_artifacts().items()} + for environment in universe.get_environment_artifacts()} + + +async def _items(deployed) -> str: + async with streamable_http_client(deployed.mcp_url) as (read, write, _): + async with ClientSession(read, write) as session: + await session.initialize() + return " ".join(part.text for part in (await session.call_tool("list_items", {})).content if part.type == "text") + + def _containers(sandbox_id: str) -> list[str]: return _docker("ps", "-aq", "--filter", f"name=agent-{sandbox_id}").stdout.split() @@ -111,12 +141,32 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its listed, shot = await _tools(deployed) async with httpx.AsyncClient(timeout=30) as client: card = (await client.get(f"{deployed.gateway_url}/svc/desktop{WELL_KNOWN_PATH}")).json() + # Load, snapshot and reset reach the computer through the multi env, beside its MCP server. + uid, own = uuid.uuid4().hex[:8], DeployedEnv.from_dict(computer) + world = _universe(uid, {"Documents/note.txt": b"from the universe"}) + await LoadArtifactTaskStep(id="seed", version=None, env_id=office.id, artifact_id=world.id).execute(context) + note = (await inside.run(own, ["cat", "Documents/note.txt"], timeout_s=30))["stdout"] + listed_items = await _items(deployed) + await SnapshotEnvTaskStep(id="snap", version=None, env_id=office.id, + snapshot_id=f"office-snap-{uid}").execute(context) + snapshot = _snapshotted(context, "snap") + await ResetEnvTaskStep(id="reset", version=None, env_id=office.id, fail_task_on_error=True).execute(context) + after_reset = (await inside.run(own, ["sh", "-c", "test -e Documents/note.txt && echo kept || echo gone"], + timeout_s=30))["stdout"].strip() + reset_answers = await _answers(deployed, ["desktop_computer_screenshot"]) + emptied_items = await _items(deployed) + # A reset empties the server too, so the next attempt loads again, every service and the computer. + await LoadArtifactTaskStep(id="reseed", version=None, env_id=office.id, artifact_id=world.id).execute(context) + reloaded = ((await inside.run(own, ["cat", "Documents/note.txt"], timeout_s=30))["stdout"], + await _items(deployed)) + await deployed.invoke(DISABLE_TOOL_EXTENSION_URI, DISABLE, {"role": DEFAULT_ROLE, "tools": [WILDCARD]}) await deployed.invoke(ENABLE_TOOL_EXTENSION_URI, ENABLE, {"role": DEFAULT_ROLE, "tools": ["desktop_computer_screenshot"]}) narrowed, narrowed_shot = await _tools(deployed) reattached = await Env.from_instance_id(deployed.instance_id) up = _containers(computer["sandbox_id"]) + finally: report = await teardown_run(context) @@ -130,6 +180,11 @@ async def test_a_computer_in_a_multi_env_is_served_through_its_gateway_under_its assert [env._deployed.sandbox_id for env in reattached.computer_envs] == [computer["sandbox_id"]] assert _containers(computer["sandbox_id"]) == [] assert json.dumps(deployed.child_envs) # the record stores as JSON + assert note == "from the universe" and "snap-x" in listed_items + assert {"items", "desktop"} <= set(snapshot) and snapshot["desktop"]["Documents/note.txt"] == b"from the universe" + assert after_reset == "gone" and all(reset_answers.values()), reset_answers + assert "snap-x" not in emptied_items, emptied_items + assert reloaded[0] == "from the universe" and "snap-x" in reloaded[1], reloaded @pytest.mark.asyncio diff --git a/tst/integration/env/envs/multi_env_local_test.py b/tst/integration/env/envs/multi_env_local_test.py index ce5dc5e05..92535eede 100644 --- a/tst/integration/env/envs/multi_env_local_test.py +++ b/tst/integration/env/envs/multi_env_local_test.py @@ -1,14 +1,16 @@ """A MultiEnv on the local backend: two MCP servers behind one gateway and the local Postgres store, on docker compose. -The env deploys, a fresh object restores its record as a later process would, loads a universe into one of its servers, -and close() takes the whole compose stack down. Requires a docker daemon; spins up a throwaway ``registry:2`` and skips -if it can't start. +The env deploys, a fresh object restores its record as a later process would, loads a universe into both its servers, +the reset_env step empties both (the items server through data/reset, the older slack server, which serves no card, +through its /api/reset), and close() takes the whole compose stack down. Requires a docker daemon; spins up a throwaway +``registry:2`` and skips if it can't start. """ import json import uuid from pathlib import Path +import httpx import pytest from agentenv_protocol import client as protocol_v1 @@ -17,6 +19,8 @@ from agent_env.env.env import DeployedGatewayEnv, Env from agent_env.env.envs.mcp_server import MCPServerEnv from agent_env.env.envs.multi_env import MultiEnv +from agent_env.task_step.context import TaskStepContext +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep from tst.integration.env.envs.server_env_local_test import _put_items_image from tst.integration.store.local_parallel_deploy_test import _docker, _seed_bootstrap_envs, local_stack as local_stack @@ -50,6 +54,14 @@ async def test_a_multi_env_deploys_restores_loads_and_tears_down_on_local_compos await restored.load_environment_universe_artifact(_items_universe(uid)) base_url = await legacy_protocol.v1_base_url(deployed, deployed.gateway_url, "items") assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": ["snap-x", "snap-y"]} + slack_state = f"{legacy_protocol.environment_base_url(deployed.gateway_url, 'slack')}/export-state" + assert len(httpx.get(slack_state, timeout=30).json()["channels"]) == 10 + + # A multi env without computers resets its servers, each as it resets alone, and fails if one doesn't. + await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute( + TaskStepContext(deployed_envs=[deployed])) + assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": []} + assert httpx.get(slack_state, timeout=30).json()["channels"] == [] await restored.close() assert _stack(work_dir) == "" @@ -63,10 +75,18 @@ def _stack(work_dir: Path) -> str: def _items_universe(uid: str) -> EnvironmentUniverseArtifact: + """The items server's two items, and the slack server's workspace of ten channels.""" items = EnvironmentArtifact.put( id=f"multi-items-data-{uid}", environment_name="items", file_artifact=FileArtifact.put_bytes(id=f"multi-items-file-{uid}", description="multi env e2e", filename="items.json", content=json.dumps({"items": ["snap-x", "snap-y"]}).encode(), content_type="application/json"), ) - return EnvironmentUniverseArtifact.put(id=f"multi-universe-{uid}", environment_artifacts=[items]) + slack = EnvironmentArtifact.put( + id=f"multi-slack-data-{uid}", + environment_name="slack", + file_artifact=FileArtifact.put_bytes(id=f"multi-slack-file-{uid}", description="multi env e2e", filename="slack.json", + content=(_TST_DATA / "slack_mcp/generated_data.json").read_bytes(), + content_type="application/json"), + ) + return EnvironmentUniverseArtifact.put(id=f"multi-universe-{uid}", environment_artifacts=[items, slack]) diff --git a/tst/integration/env/envs/server_env_local_test.py b/tst/integration/env/envs/server_env_local_test.py index 1285ea568..04e88dc04 100644 --- a/tst/integration/env/envs/server_env_local_test.py +++ b/tst/integration/env/envs/server_env_local_test.py @@ -38,6 +38,7 @@ from agent_env.task import EpisodeSpec, Task from agent_env.task_step.context import TaskStepContext from agent_env.task.teardown import TORN_DOWN_KEY +from agent_env.task_step.task_steps.reset_env import ResetEnvTaskStep from agent_env.task_step.task_steps.teardown_sandboxes import TeardownSandboxesTaskStep from tst.integration.utils.registry import REGISTRY_IMAGE from tst.util.a2a_test_agent import put_test_agent @@ -125,6 +126,9 @@ async def test_a_server_env_deploys_restores_loads_and_tears_down_on_local_conta await restored.load_environment_artifact(_items_artifact(uid)) base_url = await legacy_protocol.v1_base_url(deployed, None, "items") assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": ["snap-x", "snap-y"]} + await ResetEnvTaskStep(id="reset", version=None, env_id=env.id, fail_task_on_error=True).execute( + TaskStepContext(deployed_envs=[deployed])) + assert (await protocol_v1.get_data(base_url)).model_dump()["parts"][0]["data"] == {"items": []} # emptied alone too step = TeardownSandboxesTaskStep(id="teardown", version=None, env_ids=[env.id]) context = await step.execute(TaskStepContext(deployed_envs=[deployed])) diff --git a/tst/unit/bundle/computer_env_folder_test.py b/tst/unit/bundle/computer_env_folder_test.py index c30fc020c..0221673de 100644 --- a/tst/unit/bundle/computer_env_folder_test.py +++ b/tst/unit/bundle/computer_env_folder_test.py @@ -243,3 +243,39 @@ def test_a_multi_env_whose_gateway_cant_tell_its_computers_apart_by_name_is_refu assert problem in refused.value.problems, refused.value assert composed == [] + + +def _office_with_apps(root, computers, extra=None): + """``_office`` with the app folders ``APPS``, mail and notes, which its computers may name.""" + return layout(root, {**{f"envs/{folder}/env.toml": toml for folder, toml in computers.items()}, **APPS, + "envs/office/env.toml": f'type = "multi"\ncomputer_envs = {json.dumps(list(computers))}\n', + **(extra or {})}) + + +def test_a_universe_loaded_into_a_multi_env_seeds_its_computer_and_each_of_the_computers_apps(tmp_path, composed): + def loading(root, *seeded): + return _office_with_apps(root, {"desktop": WITH_APPS}, { + "artifacts/world/artifact.toml": 'type = "environment_universe"\n', + **{f"artifacts/world/{name}/a.json": "{}" for name in ("desktop", "mail", *seeded)}, + "tasks/t.json": json.dumps([{"id": "load", "type": "load_artifact", "env_id": "office", "artifact_id": "world"}])}) + + _plan(loading(tmp_path / "seeds")) + with pytest.raises(BundleError) as refused: + _plan(loading(tmp_path / "typo", "mial")) + + assert refused.value.problems == ( + "tasks/t.json: step 'load': artifacts/world/mial seeds an environment named 'mial', and envs/office has no server " + "by that name ('desktop', 'mail', 'notes'); name it after the server it seeds, or leave it out",) + + +def test_a_multi_env_whose_computers_share_an_apps_name_is_refused_before_any_write(tmp_path, composed): + laptop = WITH_APPS.replace('apps = ["notes", { env = "mail", install = "build" }]', 'apps = ["mail"]') + with pytest.raises(BundleError) as refused: + _plan(_office_with_apps(tmp_path / "desk", {"desktop": WITH_APPS, "laptop": laptop}, { + "tasks/t.json": json.dumps([{"id": "load", "type": "load_artifact", "env_id": "office", "artifact_id": "notes"}]), + "artifacts/notes/notes.txt": "a note\n"})) + + assert [problem for problem in refused.value.problems if "app 'mail'" in problem] == [ + f"envs/office: computer_envs: app 'mail' of computer '{name}' has the name of another of its child envs, and " + "loads and snapshots find an environment by its name" for name in ("desktop", "laptop")] + assert composed == [] diff --git a/tst/unit/env/envs/test_multi_env_computers.py b/tst/unit/env/envs/test_multi_env_computers.py index c78e4f24c..50d112519 100644 --- a/tst/unit/env/envs/test_multi_env_computers.py +++ b/tst/unit/env/envs/test_multi_env_computers.py @@ -21,8 +21,10 @@ from agent_env.env.envs.multi_env import MultiEnv from agent_env.env.gateway import ExternalChild from agent_env.env.gateway.constants import WELL_KNOWN_PATH +from agent_env.env.store import EnvInstanceStore from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider from agent_env.providers.env_providers.env_provider import EnvironmentProvider +from agent_env.providers.env_state import LocalPostgresStateProvider from agent_env.task.teardown import env_sandbox_ids from tst.util.sandbox_providers import mock_provider @@ -40,10 +42,36 @@ class FakeComputer: type = COMPUTER_ENV_TYPE - def __init__(self, name: str, *, fails: Exception | None = None, refusal: str | None = None, log: list | None = None): + def __init__(self, name: str, *, fails: Exception | None = None, refusal: str | None = None, log: list | None = None, + apps: tuple[str, ...] = (), resets: Exception | None = None, loads: Exception | None = None): self.id, self.version, self.environment_name = f"{name}-computer", 1, name self.fails, self.refusal, self.log = fails, refusal, [] if log is None else log self.deploys, self.refusals, self._deployed, self.closes = [], [], None, 0 + self.apps, self.reset_fails, self.load_fails = apps, resets, loads + + def composed_apps(self): + return [SimpleNamespace(environment_name=app) for app in self.apps] + + def holds(self, environment_name): + return environment_name in (self.environment_name, *self.apps) + + async def load_environments(self, environments): + inspect.signature(ComputerEnv.load_environments).bind(self, environments) + await asyncio.sleep(0.01) + self.log.append(("loaded", self.environment_name, [environment.environment_name for environment in environments])) + if self.load_fails: + raise self.load_fails + + async def load_environment_artifact(self, environment_artifact): + inspect.signature(ComputerEnv.load_environment_artifact).bind(self, environment_artifact) + self.log.append(("loaded", self.environment_name, [environment_artifact.environment_name])) + + async def reset(self, deployed): + inspect.signature(ComputerEnv.reset).bind(self, deployed) + await asyncio.sleep(0.01) + self.log.append(("reset", self.environment_name, deployed.sandbox_id)) + if self.reset_fails: + raise self.reset_fails def deploy_refusal(self, **options): inspect.signature(ComputerEnv.deploy_refusal).bind(self, **options) # only what the real one takes @@ -344,3 +372,212 @@ def test_cli_put_names_a_computer_name_the_multi_env_refuses(): patch("agent_env.cli.env.multi.detect_base_metadata", return_value={}): result = CliRunner().invoke(multi, ["put", "--id", "office", "--computer", "desktop-number-one-computer"]) assert result.exit_code == 1 and "is 19 characters, and a tool prefix is at most 16" in result.output + + +# --- load and reset through the multi env --- + +def _artifact(name: str) -> SimpleNamespace: + return SimpleNamespace(environment_name=name) + + +@pytest.mark.parametrize("computers, others, problems", [ + ({"desktop": ["mail", "notes"]}, ["slack", "desktop"], []), + ({"desktop": ["slack"]}, ["slack", "desktop"], [ + "app 'slack' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), + ({"desktop": ["mail"], "laptop": ["mail"]}, ["desktop", "laptop"], [ + "app 'mail' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name", + "app 'mail' of computer 'laptop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), + ({"desktop": ["laptop"]}, ["desktop", "laptop"], [ + "app 'laptop' of computer 'desktop' has the name of another of its child envs, and loads and snapshots find an " + "environment by its name"]), +], ids=["own", "a-server", "two-computers", "another-computer"]) +def test_a_computers_apps_names_are_no_other_child_envs(computers, others, problems): + assert _multi_computers.app_name_problems(computers, others) == problems + + +def test_a_multi_env_refuses_a_computer_whose_app_another_child_env_names(): + with pytest.raises(ValueError, match="app 'slack' of computer 'desktop' has the name of another of its child envs"): + _multi(FakeComputer("desktop", apps=("slack",)), mcp=["slack"]) + + +@pytest.mark.asyncio +async def test_an_environment_artifact_named_for_a_computer_or_one_of_its_apps_loads_into_it(): + log = [] + env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log), mcp=["slack"]) + env._gateway_url = GATEWAY + [slack] = env.mcp_server_envs + slack.load_environment_artifact = AsyncMock() + + for name in ("notes", "desktop", "laptop", "slack"): + await env.load_environment_artifact(_artifact(name)) + + assert log == [("loaded", "desktop", ["notes"]), ("loaded", "desktop", ["desktop"]), ("loaded", "laptop", ["laptop"])] + slack.load_environment_artifact.assert_awaited_once() + + +@pytest.mark.asyncio +async def test_a_computer_loads_its_own_environment_before_its_apps(): + computer = SimpleNamespace(computer_name="desktop", _load=AsyncMock()) + await ComputerEnv.load_environments(computer, [_artifact("notes"), _artifact("desktop"), _artifact("mail")]) + assert [environment.environment_name for environment in computer._load.await_args.args[0]] == [ + "desktop", "notes", "mail"] + + +async def _load_universe(env: MultiEnv, log: list, *, restored: bool) -> MagicMock: + """Load a universe of five environments into ``env``, restored from a clean snapshot or re-ingested, each + service's load or the restore in ``log``; the universe, whose reads of its environments a test counts.""" + env._instance_id, env._sandbox = "inst", MagicMock(mode="vm", exec_script=AsyncMock(return_value="8\n")) + env._env_provider = EnvironmentGatewayProvider() + env._env_provider._state_provider = LocalPostgresStateProvider() + env._load_from_snapshot = AsyncMock(side_effect=lambda snapshot: log.append(("restored",))) + env.load_environment_artifact = AsyncMock(side_effect=lambda artifact: log.append(("service", artifact.environment_name))) + universe = MagicMock(id="uni", version=1, **{"get_metadata.return_value": {}}) + universe.get_environment_artifacts.return_value = [_artifact(name) for name in ("notes", "a", "desktop", "laptop", "b")] + snapshots = MagicMock(**{"get_clean.return_value": MagicMock() if restored else None}) + with patch("agent_env.env.store.get_env_instance_store", return_value=MagicMock(**{"get_loaded_environments.return_value": []})), \ + patch("agent_env.env.snapshot_store.get_env_snapshot_store", return_value=snapshots), \ + patch("agent_env.env.snapshot_store.compute_env_fingerprint", return_value="fp"), \ + patch("agent_env.env.snapshot_store._check_changelog_empty", AsyncMock(return_value=True)), \ + patch("agent_env.env.store.update_env_instance_environment_universe", MagicMock()): + await env.load_environment_universe_artifact(universe, snapshot_after_load=False) + return universe + + +@pytest.mark.asyncio +@pytest.mark.parametrize("restored", [False, True], ids=["re-ingested", "restored"]) +async def test_a_universe_loads_each_computers_environments_after_the_services_even_after_a_restore(restored): + log = [] + env = _multi(FakeComputer("desktop", apps=("notes",), log=log), FakeComputer("laptop", log=log)) + + universe = await _load_universe(env, log, restored=restored) + + services = [("restored",)] if restored else [("service", "a"), ("service", "b")] + assert log[:len(services)] == services + assert sorted(log[len(services):]) == [("loaded", "desktop", ["notes", "desktop"]), ("loaded", "laptop", ["laptop"])] + assert universe.get_environment_artifacts.call_count == 1 # the services and the computers load the same read + + +@pytest.mark.asyncio +@pytest.mark.parametrize("restored, reads", [(False, 1), (True, 0)], ids=["re-ingested", "restored"]) +async def test_a_multi_env_without_computers_reads_the_universes_environments_only_to_re_ingest_them(restored, reads): + log = [] + + universe = await _load_universe(_multi(mcp=["a", "b"]), log, restored=restored) + + assert log == ([("restored",)] if restored else [("service", name) for name in ("notes", "a", "desktop", "laptop", "b")]) + assert universe.get_environment_artifacts.call_count == reads # a restore needs none of them, as before computers + + +@pytest.mark.asyncio +async def test_each_computer_that_fails_to_load_is_named_once_every_computer_has_loaded(): + log = [] + env = _multi(FakeComputer("desktop", log=log, loads=RuntimeError("disk full")), + FakeComputer("laptop", log=log, loads=ValueError("bad path")), FakeComputer("kiosk", log=log)) + + with pytest.raises(RuntimeError) as raised: + await env._computers.load([_artifact(name) for name in ("desktop", "laptop", "kiosk")]) + + assert str(raised.value) == ("multi env 'office': computer 'desktop' failed to load: RuntimeError('disk full'); " + "computer 'laptop' failed to load: ValueError('bad path')") + assert sorted(name for _, name, _ in log) == ["desktop", "kiosk", "laptop"] + + +@pytest.fixture +def server_resets(monkeypatch): + """Each MCP server's and website's reset, as (name, mcp) in ``log``, attached to the multi env's record: False, as + for one serving no reset, for a name in ``unserved``, and raising for one in ``failing``; the instance whose loads + are forgotten in ``forgotten``, with how many servers had reset by then.""" + resets = SimpleNamespace(log=[], unserved=set(), failing={}, forgotten=[], attached=[]) + + async def reset(env, *, mcp): + inspect.signature(_deployment.reset_server_data).bind(env, mcp=mcp) + await asyncio.sleep(0.01) + resets.log.append((env.environment_name, mcp, env._deployed.instance_id)) + if env.environment_name in resets.failing: + raise resets.failing[env.environment_name] + return env.environment_name not in resets.unserved + + async def attached(cls, deployed): + resets.attached.append(deployed.instance_id) + env = _multi(mcp=["slack"], websites=["shop"]) + for child in [*env.mcp_server_envs, *env.website_envs]: + child._deployed = deployed + return env + + monkeypatch.setattr("agent_env.env.envs.multi_env.reset_server_data", reset) + monkeypatch.setattr(MultiEnv, "_attached", classmethod(attached)) + monkeypatch.setattr(EnvInstanceStore, "clear_loaded_environments", + lambda store, instance_id: resets.forgotten.append((instance_id, len(resets.log)))) + return resets + + +async def _stored(*computers) -> DeployedEnv: + """The record of a multi env with ``computers``, as reset_env reads it back.""" + deployed = await _multi(*computers, mcp=["slack"], websites=["shop"]).deploy() + return DeployedEnv.from_dict({**dataclasses.asdict(deployed), "instance_id": "inst-1"}) + + +@pytest.mark.asyncio +async def test_reset_resets_every_child_env_at_once_each_as_it_resets_alone_and_forgets_what_loads_put_in( + gateway, providers, server_resets): + stored, log = await _stored(FakeComputer("desktop"), FakeComputer("laptop")), [] + + await _multi(FakeComputer("desktop", log=log), FakeComputer("laptop", log=log), mcp=["slack"], + websites=["shop"]).reset(stored) + + assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] + assert sorted(server_resets.log) == [("shop", False, "inst-1"), ("slack", True, "inst-1")] + assert server_resets.attached == ["inst-1"] and server_resets.forgotten == [("inst-1", 0)] # before any reset + + +@pytest.mark.asyncio +async def test_a_multi_env_of_computers_alone_resets_them_without_reattaching_its_gateway(gateway, providers, + server_resets): + deployed, log = await _multi(FakeComputer("desktop")).deploy(), [] + + await _multi(FakeComputer("desktop", log=log)).reset(DeployedEnv.from_dict(dataclasses.asdict(deployed))) + + assert log == [("reset", "desktop", "sb-desktop")] and server_resets.attached == server_resets.log == [] + + +@pytest.mark.asyncio +async def test_a_server_serving_no_reset_stays_as_it_is_and_the_rest_reset(gateway, providers, server_resets, caplog): + stored, log = await _stored(FakeComputer("desktop")), [] + server_resets.unserved.add("shop") + + with caplog.at_level("INFO"): + await _multi(FakeComputer("desktop", log=log), mcp=["slack"], websites=["shop"]).reset(stored) + + assert log == [("reset", "desktop", "sb-desktop")] and len(server_resets.log) == 2 + assert "multi env 'office': website 'shop' serves no reset and takes no load, so it stays as it is" in caplog.text + + +@pytest.mark.asyncio +async def test_each_child_that_fails_to_reset_is_named_once_every_child_env_has_reset(gateway, providers, server_resets): + stored, log = await _stored(FakeComputer("desktop"), FakeComputer("laptop")), [] + server_resets.failing["slack"] = RuntimeError("data/reset timed out") + env = _multi(FakeComputer("desktop", log=log, resets=RuntimeError("no reboot")), FakeComputer("laptop", log=log), + mcp=["slack"], websites=["shop"]) + + with pytest.raises(RuntimeError) as raised: + await env.reset(stored) + + assert str(raised.value) == ("multi env 'office': computer 'desktop' failed to reset: RuntimeError('no reboot'); " + "MCP server 'slack' failed to reset: RuntimeError('data/reset timed out')") + assert sorted(log) == [("reset", "desktop", "sb-desktop"), ("reset", "laptop", "sb-laptop")] + assert len(server_resets.log) == 2 and server_resets.forgotten == [("inst-1", 0)] + + +@pytest.mark.asyncio +async def test_a_reset_that_cannot_forget_what_loads_put_in_empties_nothing(gateway, providers, server_resets, + monkeypatch): + stored, log = await _stored(FakeComputer("desktop")), [] + monkeypatch.setattr(EnvInstanceStore, "clear_loaded_environments", MagicMock(side_effect=OSError("store down"))) + + with pytest.raises(OSError, match="store down"): + await _multi(FakeComputer("desktop", log=log), mcp=["slack"], websites=["shop"]).reset(stored) + + assert log == server_resets.log == [] # a resumed load would skip a service a reset had emptied diff --git a/tst/unit/env/envs/test_server_reset.py b/tst/unit/env/envs/test_server_reset.py new file mode 100644 index 000000000..a73236dc1 --- /dev/null +++ b/tst/unit/env/envs/test_server_reset.py @@ -0,0 +1,177 @@ +"""An MCP server's or website's reset empties what loads put in, as each load does before it adds: through data/reset, or +an older server's /api/reset, its changelog started afresh after; one serving no reset takes no load and is left as it +is. Alone, each attaches to its record as a load does.""" + +from __future__ import annotations + +import json +from types import SimpleNamespace +from unittest.mock import AsyncMock, MagicMock, patch + +import httpx +import pytest +from mcp.types import CallToolResult, TextContent + +from agent_env.env.env import DeployedEnv +from agent_env.env.envs import _deployment, mcp_server, website +from agent_env.env.envs.mcp_server import MCPServerEnv +from agent_env.env.envs.website import WebsiteEnv +from agent_env.env.gateway.constants import DATA_PLANE_LOAD_TIMEOUT_S +from agent_env.providers.env_providers.env_gateway_provider import EnvironmentGatewayProvider + +GATEWAY = "https://gw.example" + + +@pytest.fixture +def server(monkeypatch): + """Each request a reset sends, in ``requests``, answered ``status``; and the changelog triggers installed after it.""" + seen = SimpleNamespace(requests=[], status=200, triggers=AsyncMock()) + real = httpx.AsyncClient + + def handle(request): + seen.requests.append(request) + return httpx.Response(seen.status, json={"jsonrpc": "2.0", "id": 1, "result": {}}) + + monkeypatch.setattr(httpx, "AsyncClient", lambda *a, **k: real(transport=httpx.MockTransport(handle))) + monkeypatch.setattr(EnvironmentGatewayProvider, "install_changelog_triggers", seen.triggers) + return seen + + +def _record(card: dict | None) -> DeployedEnv: + return DeployedEnv(env_id="mcp-email", env_version=1, env_provider_type="gateway", instance_id="inst-1", + environment_card_url=f"{GATEWAY}/.well-known/agent-env.json", environment_card=card) + + +def _server(card: dict | None, env_provider_type: str = "gateway") -> MCPServerEnv: + """The email server behind a gateway of ours, attached to a record keeping ``card``.""" + env = MCPServerEnv(id="mcp-email", version=1, docker_image_artifact=MagicMock(), environment_name="email", + env_provider_type=env_provider_type) + env._deployed, env._gateway_url = _record(card), GATEWAY + return env + + +def _card(*operations: str) -> dict: + return {"name": "email", "url": "/agentenv", "capabilities": {"operations": list(operations)}} + + +@pytest.mark.asyncio +@pytest.mark.parametrize("card", [_card("data/reset", "data/add", "data/get"), {"name": "email", "url": "/agentenv"}], + ids=["declared", "an-older-card-declaring-none"]) +async def test_a_server_serving_data_reset_is_emptied_through_it_and_its_changelog_starts_afresh(server, card): + assert await _deployment.reset_server_data(_server(card), mcp=True) is True + + [request] = server.requests + assert (str(request.url), json.loads(request.content)["method"]) == (f"{GATEWAY}/agentenv", "data/reset") + assert request.extensions["timeout"]["read"] == DATA_PLANE_LOAD_TIMEOUT_S # a load's budget, not the client's 30 s + server.triggers.assert_awaited_once_with("email") + + +@pytest.mark.asyncio +async def test_a_server_whose_card_declares_no_data_reset_takes_no_load_and_is_left_as_it_is(server): + assert await _deployment.reset_server_data(_server(_card()), mcp=True) is False + assert server.requests == [] and not server.triggers.await_count + + +@pytest.mark.asyncio +@pytest.mark.parametrize("status, reset", [(200, True), (404, False)], ids=["serves-it", "serves-none"]) +async def test_an_older_server_is_emptied_through_its_api_reset_and_one_answering_404_has_none(server, status, reset): + server.status = status + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=False)) as offers: + assert await _deployment.reset_server_data(_server(None), mcp=True) is reset + + [request] = server.requests + assert (request.method, str(request.url)) == ("POST", f"{GATEWAY}/svc/mcp-email/api/reset") + assert server.triggers.await_count == reset + assert [call.args for call in offers.await_args_list] == ([] if reset else [(f"{GATEWAY}/mcp", "email_reset")]) + + +@pytest.mark.asyncio +async def test_an_older_server_answering_404_resets_through_its_tool_with_no_seed_to_the_data_it_boots_with(server): + server.status = 404 + tool = AsyncMock(return_value=CallToolResult(content=[TextContent(type="text", text="Data reset for email.")])) + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=True)), \ + patch("agent_env.env.legacy_protocol.reset_via_mcp_tool", tool): + assert await _deployment.reset_server_data(_server(None), mcp=True) is True + + tool.assert_awaited_once_with(f"{GATEWAY}/mcp", "email") # no seed + server.triggers.assert_awaited_once_with("email") + + +@pytest.mark.asyncio +async def test_an_older_server_whose_reset_tool_fails_fails_its_reset_named(server): + server.status = 404 + failed = CallToolResult(content=[TextContent(type="text", text="database is locked")], isError=True) + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + patch("agent_env.env.legacy_protocol.offers_tool", AsyncMock(return_value=True)), \ + patch("agent_env.env.legacy_protocol.reset_via_mcp_tool", AsyncMock(return_value=failed)), \ + pytest.raises(RuntimeError, match="^MCP server 'email': its email_reset tool failed: database is locked$"): + await _deployment.reset_server_data(_server(None), mcp=True) + assert not server.triggers.await_count + + +@pytest.mark.asyncio +async def test_an_older_server_failing_its_reset_fails_it(server): + server.status = 500 + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)), \ + pytest.raises(httpx.HTTPStatusError): + await _deployment.reset_server_data(_server(None), mcp=True) + assert not server.triggers.await_count + + +@pytest.mark.asyncio +async def test_a_server_a_plugin_deployed_with_no_data_plane_is_left_as_it_is(server): + env = _server(None, env_provider_type="gateway") + env._env_provider = MagicMock() # a plugin's provider, no built-in + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=None)): + assert await _deployment.reset_server_data(env, mcp=True) is False + assert server.requests == [] + + +@pytest.mark.asyncio +async def test_a_website_is_emptied_at_its_own_path(server): + env = WebsiteEnv(id="shop-site", version=1, server_docker_image_artifact=MagicMock(), environment_name="shop") + env._deployed, env._gateway_url = None, GATEWAY # a name an MCP server shares: the live probe, no record + with patch("agent_env.env.legacy_protocol.v1_base_url", AsyncMock(return_value=f"{GATEWAY}/svc/shop")) as base: + assert await _deployment.reset_server_data(env, mcp=False) is True + + assert base.await_args.kwargs == {"mcp": False} + assert [str(request.url) for request in server.requests] == [f"{GATEWAY}/svc/shop/agentenv"] + server.triggers.assert_awaited_once_with("shop") + + +@pytest.mark.asyncio +async def test_a_server_not_deployed_cannot_reset(server): + env = _server(None) + env._deployed = env._gateway_url = None + with pytest.raises(RuntimeError, match="not deployed"): + await _deployment.reset_server_data(env, mcp=True) + + +@pytest.mark.asyncio +@pytest.mark.parametrize("cls, module, mcp, what", [ + (MCPServerEnv, mcp_server, True, "MCP server 'email'"), + (WebsiteEnv, website, False, "website 'email'"), +], ids=["mcp-server", "website"]) +async def test_alone_each_attaches_to_its_record_as_a_load_does_and_one_serving_no_reset_has_none( + monkeypatch, cls, module, mcp, what): + record, attached, calls, served = _record(None), SimpleNamespace(environment_name="email"), [], [True, False] + + async def attach(_cls, deployed): + calls.append(("attach", deployed)) + return attached + + async def reset(env, *, mcp): + calls.append(("reset", env, mcp)) + return served.pop(0) + + monkeypatch.setattr(cls, "from_deployed_env", classmethod(attach)) + monkeypatch.setattr(module, "reset_server_data", reset) + env = cls("email-env", 1, MagicMock(), environment_name="email") + + await env.reset(record) + with pytest.raises(NotImplementedError, match=f"^{what} serves no reset$"): + await env.reset(record) + + assert calls == [("attach", record), ("reset", attached, mcp)] * 2 diff --git a/tst/unit/env/test_legacy_protocol.py b/tst/unit/env/test_legacy_protocol.py index baae080d0..67c2ba8d2 100644 --- a/tst/unit/env/test_legacy_protocol.py +++ b/tst/unit/env/test_legacy_protocol.py @@ -293,3 +293,47 @@ async def test_a_stored_cards_website_and_mcp_server_sharing_a_name_are_each_rea assert await legacy_protocol.v1_base_url(deployed, None, "mail", mcp=True) == "http://gw:18765/svc/mcp-mail" assert (await legacy_protocol.child_env_card(deployed, None, "mail", mcp=False))[1] is site assert (await legacy_protocol.child_env_card(deployed, None, "mail", mcp=True))[1] is server + + +@pytest.mark.asyncio +@pytest.mark.parametrize("gateway", ["http://gw", None]) +async def test_backing_servers_list_a_multi_envs_computer_and_its_apps_from_its_own_record(gateway): + """Not at the gateway's /svc//, which carries no token of the computer's and reads as a website's route.""" + import dataclasses + from types import SimpleNamespace + + gateway_card = {"name": "office", "url": RPC_PATH, "children_environments": [ + {"name": "slack", "url": "/svc/mcp-slack/agentenv"}, {"name": "desktop", "url": "/svc/desktop/agentenv"}]} + computer_card = {"name": "desktop", "url": RPC_PATH, "capabilities": {"operations": ["data/get"]}, + "children_environments": [{"name": "notes", "url": "/svc/notes/agentenv"}]} + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", environment_card=computer_card) + record = _record(gateway_card) + record.child_envs = {"desktop": dataclasses.asdict(computer)} + env = SimpleNamespace(mcp_server_envs=[SimpleNamespace(environment_name="slack")], website_envs=[]) + + servers = await legacy_protocol.backing_servers(record, gateway, env) + + assert [(s.environment_name, s.address, s.record.control_token if s.record else None) for s in servers] == [ + ("slack", "https://env.example", None), ("desktop", "https://desk.example", "desk-token"), + ("notes", "https://desk.example", "desk-token")] + assert await legacy_protocol.server_v1_base_url(servers[2], gateway) == "https://desk.example/svc/notes" + + +@pytest.mark.asyncio +async def test_backing_servers_use_a_records_computers_only_for_its_own_gateway(monkeypatch): + """Another gateway's card is another deployment's, whose computers this record doesn't hold.""" + import dataclasses + from types import SimpleNamespace + + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", + environment_card={"name": "desktop", "url": RPC_PATH}) + record = _record({"name": "office", "url": RPC_PATH, "children_environments": [{"name": "desktop", "url": "/svc/desktop/agentenv"}]}) + record.child_envs = {"desktop": dataclasses.asdict(computer)} + other = {"name": "office", "url": RPC_PATH, "children_environments": [{"name": "desktop", "url": "/svc/desktop/agentenv"}]} + monkeypatch.setattr(legacy_protocol.protocol_v1, "get_card", AsyncMock(return_value=other)) + + servers = await legacy_protocol.backing_servers(record, "http://another-gw", SimpleNamespace(mcp_server_envs=[], website_envs=[])) + + assert [(s.environment_name, s.address, s.record) for s in servers] == [("desktop", "http://another-gw", None)] diff --git a/tst/unit/task_step/sync_env_clock_test.py b/tst/unit/task_step/sync_env_clock_test.py index a9a109e2a..e95acf2b3 100644 --- a/tst/unit/task_step/sync_env_clock_test.py +++ b/tst/unit/task_step/sync_env_clock_test.py @@ -439,6 +439,33 @@ async def test_a_website_sharing_an_mcp_servers_name_is_synced_with_the_envs_con assert [s["service"] for s in context.metadata["clock_configurations"][0]["synced"]] == ["email", "email"] +@pytest.mark.asyncio +async def test_a_multi_envs_computer_is_synced_at_its_own_address_with_its_own_control_token(monkeypatch): + """Not through the gateway's /svc/desktop/, which carries the gateway's token, not the computer's.""" + import dataclasses + from unittest.mock import patch + + from agent_env.env.env import DeployedSandboxEnv + from agent_env.env.gateway.constants import WELL_KNOWN_PATH + + sent = _mock_http(monkeypatch, state={"env_get_time_url": CLOCK_URL}) + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url=f"https://desk.example{WELL_KNOWN_PATH}", + environment_card={"name": "desktop", "url": "/agentenv", + "capabilities": {"extensions": [_CLOCK_EXT]}}) + record = dataclasses.replace(_carded(await _composed_card({"mcp-email": [_CLOCK_EXT], "desktop": [_CLOCK_EXT]})), + control_token="gateway-token", child_envs={"desktop": dataclasses.asdict(computer)}) + env = SimpleNamespace(mcp_server_envs=[SimpleNamespace(environment_name="email")], website_envs=[]) + + with patch("agent_env.env.env.Env.get", return_value=env): + await _step().execute(TaskStepContext(deployed_envs=[record])) + + syncs = {str(r.url): r.headers for r in sent if r.url.path.endswith("/sync_time")} + assert set(syncs) == {f"{_CARD}/svc/mcp-email/agentenv/ext/sync_time", "https://desk.example/agentenv/ext/sync_time"} + assert {k: syncs["https://desk.example/agentenv/ext/sync_time"].get(k) for k in computer.control_headers} == \ + computer.control_headers + + def test_a_padded_zone_is_stored_and_sent_stripped(): s = _zoned(timezone=" America/New_York ") assert s.timezone == "America/New_York" and s.to_dict()["timezone"] == "America/New_York" diff --git a/tst/unit/task_step/test_apply_server_config.py b/tst/unit/task_step/test_apply_server_config.py index 94ed35986..9df2a67ec 100644 --- a/tst/unit/task_step/test_apply_server_config.py +++ b/tst/unit/task_step/test_apply_server_config.py @@ -837,3 +837,40 @@ def _carded_context(card: dict) -> TaskStepContext: ctx.deployed_envs[0].environment_card_url = f"{_CARD}{WELL_KNOWN_PATH}" ctx.deployed_envs[0].environment_card = card return ctx + + +@pytest.mark.asyncio +@pytest.mark.parametrize("service", ["desktop", "*"], ids=["named", "broadcast"]) +async def test_a_multi_envs_computer_is_configured_at_its_own_address_with_its_own_token(service): + """Not through the gateway's /svc/desktop/, which carries the gateway's token, not the computer's.""" + import dataclasses + + from agent_env.env.env import DeployedSandboxEnv + + computer = DeployedSandboxEnv(env_id="desk", env_version=1, sandbox_id="sb-desk", control_token="desk-token", + environment_card_url="https://desk.example/.well-known/agent-env.json", + environment_card={**_card(_ext(_SET_ERRORS_URI, "/agentenv/ext/set_errors")), "name": "desktop"}) + record = DeployedGatewayEnv(env_id="env-x", env_version=1, gateway_url=_GATEWAY, mcp_url="", sandbox_id="sb-env", + control_token="gateway-token", environment_card_url=f"{_GATEWAY}/.well-known/agent-env.json", + environment_card={"name": "office", "url": "/agentenv", "children_environments": [ + {"name": "desktop", "url": "/svc/desktop/agentenv", "capabilities": {"extensions": []}}]}, + child_envs={"desktop": dataclasses.asdict(computer)}) + sent = [] + + class Client: + async def request(self, method, url, *, json=None, timeout=None, headers=None): + sent.append((url, headers)) + return _resp(200, url, {"ok": True}) + + async def __aenter__(self): + return self + + async def __aexit__(self, *a): + return False + + step = _step(directives=[{"service": service, "uri": _SET_ERRORS_URI, "args": {"tool_name": "t", "error_rate": 0.5}}]) + with patch("httpx.AsyncClient", return_value=Client()), \ + patch("agent_env.env.env.Env.get", return_value=SimpleNamespace(mcp_server_envs=[], website_envs=[])): + await step.execute(TaskStepContext(deployed_envs=[record])) + + assert sent == [("https://desk.example/agentenv/ext/set_errors", computer.control_headers)]