agentenv-framework-protocol 0.1.432__tar.gz → 0.1.434__tar.gz

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.432
+Version: 0.1.434
 Summary: Open data-plane protocol and server SDK for agent environments.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs
@@ -717,8 +717,9 @@ class MailApp(ComputerAppEnvironment):
 
 - **`@computer_app`** names the platforms the app supports, as a driver names them, and the
   `permissions` it needs of the computer. Its env.toml names the rest: the app itself
-  (`environment_name`), the `computer` and `driver` it deploys alone on, and `build_settings`, its
-  build settings' values (`build_settings = { locale = "fr_FR" }`).
+  (`environment_name`), the `computer` and `driver` it deploys alone on, `build_settings`, its
+  build settings' values (`build_settings = { locale = "fr_FR" }`), and `[settings]`, defaults for its
+  `Settings` each deploy starts from.
 - **`@linux(...)`** is how a Linux computer installs it, `Linux`'s fields: `files`, a folder of the app's
   copied under its prefix, which holds the class's file; `packages`, the OS's, as apt takes them
   (`Packages(apt=["name", "name=version", "name/suite"])`); `python`, a requirements file there,
@@ -754,9 +755,13 @@ class MailApp(ComputerAppEnvironment):
 - **Its data** is under the `paths` its OS's decorator names, relative to the session user's home,
   none inside another (`@linux(..., paths=["Mail", ".config/mail/accounts.json"])`), or what its own
   `@add_data`, `@get_data` and `@reset_data` hooks serve instead (below).
-- **`Settings`** is typed; a computer hands each app the values a deploy gives it, as one JSON value
-  in `APP_SETTINGS_ENV` (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads
-  its own, by `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
+- **`Settings`** is typed. Its values come from the app env's `[settings]`, then the computer env's
+  `settings` beside the app in its `apps` (`apps = [{ env = "mail", settings = { signature = "-- Ada" } }]`),
+  then the deploy's `env_params` `app_settings`, each over the one before by top-level field (a table
+  or list is replaced whole). Each is checked at put; a required one may be left to the deploy, which
+  checks them merged. A computer hands each app its values as one JSON value in `APP_SETTINGS_ENV`
+  (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads its own, by
+  `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
 - **`BuildSettings`** is typed too: values the app's env fixes in its computer's image, which only
   another image changes, so a deploy can't give one. The composer writes them to
   `.agentenv/build_settings.json` in the app's folder, and the base class reads them, over the
@@ -808,9 +813,12 @@ are the profile's template. The base class adds:
 - **Its settings**, `BrowserSettings`, which a subclass's `Settings` extends: `start_urls`, opened in
   tabs at launch, the first active (`["about:blank"]` by default; none may start with `-`), headless
   the first from its command line and the rest over its pipe, since headless Chromium takes one; `window`,
-  1280 × 800, alone only; `locale`; and `time_zone`, set as `TZ` in its launch's `env`.
-- **The flags agentenv owns**, after the subclass's command and before the start tabs: its profile,
-  `--remote-debugging-pipe`, `--no-first-run`, `--no-default-browser-check` and `--lang`. With
+  1280 × 800, alone only; `locale`; `time_zone`, set as `TZ` in its launch's `env`; and `geolocation` and
+  `notifications`, `deny` (the default), which answers a page's prompt for it, or `ask`.
+- **The flags agentenv owns**, after the subclass's command and before the start tabs: its profile, its
+  HTTP cache under `~/.cache` (`--disk-cache-dir`), `--remote-debugging-pipe`, `--no-first-run`,
+  `--no-default-browser-check`, `--lang` and, when `/dev/shm` holds under 1 GiB (Docker gives 64 MiB),
+  `--disable-dev-shm-usage`, so it keeps its shared memory in files. With
   `AGENTENV_SITE_PROXY` set, it goes out through that proxy, with WebRTC's non-proxied UDP off.
   Alone it bypasses nothing, loopback included; in a computer it bypasses loopback (`127.0.0.1`,
   `[::1]`, `localhost`), so the apps beside it stay reachable while `*.localhost` names still go
@@ -818,6 +826,9 @@ are the profile's template. The base class adds:
   except on the open web (`AGENTENV_BROWSER_OPEN_WEB=1`), and refuses to start with no proxy.
   `declaration()` refuses a subclass whose command carries any of these, or `--remote-allow-origins`, or
   any other way to open a debugging port.
+- **Before each launch** it empties its cache, so no launch inherits another's, and writes the deploy's
+  prompt answers into its profile's `Default/Preferences` (`profile.default_content_setting_values`,
+  `2` to deny, left out to ask), which it reads as it starts.
 - **Alone, no desktop**: its launch matches and waits on no window, its server adds no launcher and,
   without `DISPLAY`, waits for no display, and its ready checks say when it's ready.
 - **`write_policies`**, an install step that writes agentenv's unattended-use policies (`POLICIES`)
@@ -828,7 +839,9 @@ are the profile's template. The base class adds:
   the result or raises `DevToolsError`, and `ConnectionError` with no browser connected. No port
   listens and no `DevToolsActivePort` is written, so nothing else in the computer can reach it over
   CDP. Since only the server that launched it holds the pipe, a server that restarts stops it and
-  launches it again. The ready check `devtools_answers` asks `Browser.getVersion` over the pipe.
+  launches it again, and a launch while it runs, from its menu launcher say, opens another window over
+  the pipe rather than a second copy, which would hand its window to the first and exit. The ready check
+  `devtools_answers` asks `Browser.getVersion` over the pipe.
 - **`browser/v1`** on its card, params only: `chromium` (its `version`), `clock: "real"` and, alone,
   `window`.
 - **Its skill**: sites by their real names, files to upload in `~/Uploads` and downloads in

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/README.md

@@ -661,8 +661,9 @@ class MailApp(ComputerAppEnvironment):
 
 - **`@computer_app`** names the platforms the app supports, as a driver names them, and the
   `permissions` it needs of the computer. Its env.toml names the rest: the app itself
-  (`environment_name`), the `computer` and `driver` it deploys alone on, and `build_settings`, its
-  build settings' values (`build_settings = { locale = "fr_FR" }`).
+  (`environment_name`), the `computer` and `driver` it deploys alone on, `build_settings`, its
+  build settings' values (`build_settings = { locale = "fr_FR" }`), and `[settings]`, defaults for its
+  `Settings` each deploy starts from.
 - **`@linux(...)`** is how a Linux computer installs it, `Linux`'s fields: `files`, a folder of the app's
   copied under its prefix, which holds the class's file; `packages`, the OS's, as apt takes them
   (`Packages(apt=["name", "name=version", "name/suite"])`); `python`, a requirements file there,
@@ -698,9 +699,13 @@ class MailApp(ComputerAppEnvironment):
 - **Its data** is under the `paths` its OS's decorator names, relative to the session user's home,
   none inside another (`@linux(..., paths=["Mail", ".config/mail/accounts.json"])`), or what its own
   `@add_data`, `@get_data` and `@reset_data` hooks serve instead (below).
-- **`Settings`** is typed; a computer hands each app the values a deploy gives it, as one JSON value
-  in `APP_SETTINGS_ENV` (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads
-  its own, by `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
+- **`Settings`** is typed. Its values come from the app env's `[settings]`, then the computer env's
+  `settings` beside the app in its `apps` (`apps = [{ env = "mail", settings = { signature = "-- Ada" } }]`),
+  then the deploy's `env_params` `app_settings`, each over the one before by top-level field (a table
+  or list is replaced whole). Each is checked at put; a required one may be left to the deploy, which
+  checks them merged. A computer hands each app its values as one JSON value in `APP_SETTINGS_ENV`
+  (`AGENTENV_APP_SETTINGS`, the apps' values by name), and the base class reads its own, by
+  `ENVIRONMENT_NAME`, as `self.settings`. A `SecretStr` field is a secret.
 - **`BuildSettings`** is typed too: values the app's env fixes in its computer's image, which only
   another image changes, so a deploy can't give one. The composer writes them to
   `.agentenv/build_settings.json` in the app's folder, and the base class reads them, over the
@@ -752,9 +757,12 @@ are the profile's template. The base class adds:
 - **Its settings**, `BrowserSettings`, which a subclass's `Settings` extends: `start_urls`, opened in
   tabs at launch, the first active (`["about:blank"]` by default; none may start with `-`), headless
   the first from its command line and the rest over its pipe, since headless Chromium takes one; `window`,
-  1280 × 800, alone only; `locale`; and `time_zone`, set as `TZ` in its launch's `env`.
-- **The flags agentenv owns**, after the subclass's command and before the start tabs: its profile,
-  `--remote-debugging-pipe`, `--no-first-run`, `--no-default-browser-check` and `--lang`. With
+  1280 × 800, alone only; `locale`; `time_zone`, set as `TZ` in its launch's `env`; and `geolocation` and
+  `notifications`, `deny` (the default), which answers a page's prompt for it, or `ask`.
+- **The flags agentenv owns**, after the subclass's command and before the start tabs: its profile, its
+  HTTP cache under `~/.cache` (`--disk-cache-dir`), `--remote-debugging-pipe`, `--no-first-run`,
+  `--no-default-browser-check`, `--lang` and, when `/dev/shm` holds under 1 GiB (Docker gives 64 MiB),
+  `--disable-dev-shm-usage`, so it keeps its shared memory in files. With
   `AGENTENV_SITE_PROXY` set, it goes out through that proxy, with WebRTC's non-proxied UDP off.
   Alone it bypasses nothing, loopback included; in a computer it bypasses loopback (`127.0.0.1`,
   `[::1]`, `localhost`), so the apps beside it stay reachable while `*.localhost` names still go
@@ -762,6 +770,9 @@ are the profile's template. The base class adds:
   except on the open web (`AGENTENV_BROWSER_OPEN_WEB=1`), and refuses to start with no proxy.
   `declaration()` refuses a subclass whose command carries any of these, or `--remote-allow-origins`, or
   any other way to open a debugging port.
+- **Before each launch** it empties its cache, so no launch inherits another's, and writes the deploy's
+  prompt answers into its profile's `Default/Preferences` (`profile.default_content_setting_values`,
+  `2` to deny, left out to ask), which it reads as it starts.
 - **Alone, no desktop**: its launch matches and waits on no window, its server adds no launcher and,
   without `DISPLAY`, waits for no display, and its ready checks say when it's ready.
 - **`write_policies`**, an install step that writes agentenv's unattended-use policies (`POLICIES`)
@@ -772,7 +783,9 @@ are the profile's template. The base class adds:
   the result or raises `DevToolsError`, and `ConnectionError` with no browser connected. No port
   listens and no `DevToolsActivePort` is written, so nothing else in the computer can reach it over
   CDP. Since only the server that launched it holds the pipe, a server that restarts stops it and
-  launches it again. The ready check `devtools_answers` asks `Browser.getVersion` over the pipe.
+  launches it again, and a launch while it runs, from its menu launcher say, opens another window over
+  the pipe rather than a second copy, which would hand its window to the first and exit. The ready check
+  `devtools_answers` asks `Browser.getVersion` over the pipe.
 - **`browser/v1`** on its card, params only: `chromium` (its `version`), `clock: "real"` and, alone,
   `window`.
 - **Its skill**: sites by their real names, files to upload in `~/Uploads` and downloads in

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.432"
+version = "0.1.434"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/src/agentenv_protocol/computer/app.py

@@ -16,7 +16,7 @@ import json
 import os
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
-from typing import Annotated, Any, Callable, ClassVar, Literal, Optional, Union
+from typing import Annotated, Any, Awaitable, Callable, ClassVar, Literal, Optional, Union
 
 from pydantic import (AfterValidator, BaseModel, ConfigDict, Field, TypeAdapter, ValidationError, create_model,
                       field_validator, model_validator)
@@ -409,7 +409,8 @@ class ComputerAppEnvironment(AgentEnvEnvironment):
             self.launch, {fn.__name__: getattr(self, fn.__name__) for fn in _methods(cls)
                           if hasattr(fn, _READY_CHECK_ATTR) and _runs_on(getattr(fn, _READY_CHECK_ATTR), on)},
             ready.timeout_s if ready is not None else DEFAULT_TIMEOUT_S, desktop=self._on_desktop(),
-            launch_fds=self._launch_fds, relaunch_on_start=self._relaunch_on_start())
+            launch_fds=self._launch_fds, relaunch_on_start=self._relaunch_on_start(),
+            launch_running=self._launch_running())
         self._computer_app_data = AppDataPlane(
             self._computer_app, {op: getattr(self, name) for op, name in cls._data_hooks.items()}, self.paths,
             cls.data_timeout_s)
@@ -431,6 +432,10 @@ class ComputerAppEnvironment(AgentEnvEnvironment):
         """Whether only the server that launched it can talk to it, so a server that restarts launches it again."""
         return False
 
+    def _launch_running(self) -> Optional[Callable[[], Awaitable[None]]]:
+        """What a launch does while it runs instead of starting a second copy: nothing, so another copy starts."""
+        return None
+
     @classmethod
     def settings_on(cls, os_type: Optional[str]) -> type[BaseModel]:
         """Its ``Settings`` on ``os_type``, with the fields its OS adds."""

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/src/agentenv_protocol/computer/app_runtime.py

@@ -50,13 +50,15 @@ class AppRuntime:
 
     def __init__(self, launch: Optional[Launch], ready_checks: dict[str, Callable[[], Any]], timeout_s: float, *,
                  desktop: bool = True, launch_fds: Optional[Callable[[], Awaitable[dict[int, int]]]] = None,
-                 relaunch_on_start: bool = False) -> None:
+                 relaunch_on_start: bool = False,
+                 launch_running: Optional[Callable[[], Awaitable[None]]] = None) -> None:
         self.launch = launch
         self.ready_checks = ready_checks
         self.timeout_s = timeout_s
         self.desktop = desktop
         self.launch_fds = launch_fds
         self.relaunch_on_start = relaunch_on_start
+        self.launch_running = launch_running
         self.started = time.time()
         self.launch_failed: Optional[str] = None
         self.checking: dict[str, asyncio.Future] = {}
@@ -84,7 +86,11 @@ class AppRuntime:
 
     async def launch_app(self) -> int:
         """Start the app from its folder, marked as launched, with the fds the app gives it, whose copies here are
-        closed once it has them; its pid."""
+        closed once it has them; its pid. With ``launch_running``, an app this server launched that still runs does
+        that instead of starting a second copy, as a browser opens another window."""
+        if self.launch_running is not None and (running := _running()) is not None:
+            await self.launch_running()
+            return running
         fds = await self.launch_fds() if self.launch_fds is not None else {}
         try:
             pid = await session.launch(self.launch.command, Path.cwd(),
@@ -156,6 +162,15 @@ def _launched_at() -> Optional[float]:
         return None
 
 
+def _running() -> Optional[int]:
+    """The pid of the app this server launched last, while it runs."""
+    try:
+        pid = int(PID.read_text())
+    except (FileNotFoundError, ValueError):
+        return None
+    return pid if session.alive(pid) else None
+
+
 async def _bounded(name: str, check: Awaitable[Optional[str]]) -> Optional[str]:
     """What ``check`` finds wrong, within ``CHECK_TIMEOUT_S``; a check that runs past it or raises says so."""
     try:

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/src/agentenv_protocol/website_browser.py

@@ -1,16 +1,19 @@
 """WebsiteBrowserEnvironment: a website browser as a computer app, run inside a computer or alone. A subclass says how
 its build installs and starts; this class adds what agentenv owns, the same in both: its flags after the subclass's
 command, the unattended-use policies, a CDP connection over the browser's debugging pipe, the settings every browser
-takes, its skill and ``browser/v1`` on its card. Whether it runs alone, on the open web and through which site proxy
-come from variables agentenv sets, never from its settings."""
+takes, a fresh cache and the deploy's prompt answers at every launch, another window for a launch while it runs, its
+skill and ``browser/v1`` on its card. Whether it runs alone, on the open web and through which site proxy come from
+variables agentenv sets, never from its settings."""
 from __future__ import annotations
 
 import asyncio
 import itertools
 import json
+import logging
 import os
+import shutil
 from pathlib import Path
-from typing import Any, ClassVar, Optional
+from typing import Any, Awaitable, Callable, ClassVar, Literal, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -18,6 +21,8 @@ from .agent_env_environment import agent_skill
 from .computer import AppDeclaration, ComputerAppEnvironment, Launch, install_step, ready_check
 from .types import EnvironmentExtension
 
+logger = logging.getLogger(__name__)
+
 ALONE_ENV = "AGENTENV_BROWSER_ALONE"
 OPEN_WEB_ENV = "AGENTENV_BROWSER_OPEN_WEB"
 SITE_PROXY_ENV = "AGENTENV_SITE_PROXY"
@@ -25,7 +30,12 @@ BROWSER = "urn:agentenv:browser/v1"
 #: The flags agentenv sets, by prefix, which a subclass's command may not carry: among them every way to open a debugging
 #: port, since the browser is reached only over its pipe.
 OWNED_FLAGS = ("--user-data-dir", "--remote-debugging-", "--remote-allow-origins", "--proxy-", "--no-proxy-server",
-               "--headless", "--window-size", "--lang", "--force-webrtc-ip-handling-policy")
+               "--headless", "--window-size", "--lang", "--force-webrtc-ip-handling-policy", "--disk-cache-dir",
+               "--disable-dev-shm-usage")
+#: Below this much /dev/shm, as Docker's 64 MiB default, the browser keeps its shared memory in files instead.
+SHM_MIN_BYTES = 1 << 30
+#: Chromium's content setting that denies a permission without a prompt.
+BLOCK = 2
 #: Alone, loopback goes through the proxy too. In a computer, the apps on loopback beside it stay reachable; ``<-loopback>``
 #: removes Chromium's own rule, so ``*.localhost`` names still don't.
 ALONE_BYPASS = "<-loopback>"
@@ -147,6 +157,9 @@ class BrowserSettings(BaseModel):
     locale: str = "en-US"
     #: The IANA time zone its pages see.
     time_zone: str = "UTC"
+    #: Whether a page asking for the location, or to show notifications, is denied without a prompt or asks.
+    geolocation: Literal["deny", "ask"] = "deny"
+    notifications: Literal["deny", "ask"] = "deny"
 
     @field_validator("start_urls")
     @classmethod
@@ -189,12 +202,20 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
     def profile_dir(self) -> Path:
         return Path.home() / self.profile
 
+    def cache_dir(self) -> Path:
+        """Its HTTP cache, kept out of its profile, which holds only its data."""
+        return Path.home() / ".cache" / Path(self.profile).name
+
     def agentenv_flags(self) -> list[str]:
         """The flags agentenv owns. A browser alone goes out only through its site proxy, so it won't launch without
         one; in a computer it goes through one when the computer has one, loopback aside."""
         settings, alone, proxy = self.settings, _alone(), os.environ.get(SITE_PROXY_ENV)
-        flags = [f"--user-data-dir={self.profile_dir()}", "--remote-debugging-pipe", "--no-first-run",
-                 "--no-default-browser-check", f"--lang={settings.locale}"]
+        flags = [f"--user-data-dir={self.profile_dir()}", f"--disk-cache-dir={self.cache_dir()}",
+                 "--remote-debugging-pipe", "--no-first-run", "--no-default-browser-check", f"--lang={settings.locale}"]
+        if (shm := _shm_bytes()) < SHM_MIN_BYTES:
+            logger.info(f"/dev/shm holds {shm // 2**20} MiB, under {SHM_MIN_BYTES // 2**20} MiB: the browser keeps its "
+                        "shared memory in files")
+            flags.append("--disable-dev-shm-usage")
         if proxy:
             flags += [f"--proxy-server={proxy}", f"--proxy-bypass-list={ALONE_BYPASS if alone else COMPUTER_BYPASS}",
                       "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"]
@@ -228,8 +249,11 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
         return self.settings.start_urls[:1] if _headless() else self.settings.start_urls
 
     async def _launch_fds(self) -> dict[int, int]:
-        """A new debugging pipe for this launch: the browser's ends as its fds 3 and 4, this server's ends its CDP
-        connection, over which the start tabs its command line can't open are opened."""
+        """Before each launch, an empty cache and the deploy's prompt answers in its profile; and a new debugging pipe:
+        the browser's ends as its fds 3 and 4, this server's ends its CDP connection, over which the start tabs its
+        command line can't open are opened."""
+        shutil.rmtree(self.cache_dir(), ignore_errors=True)
+        self._write_prompt_answers()
         to_browser_read, to_browser_write = os.pipe()
         from_browser_read, from_browser_write = os.pipe()
         await self.devtools.connect(to_browser_write, from_browser_read)
@@ -239,6 +263,24 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
             self._start_tabs.add_done_callback(lambda done: done.cancelled() or done.exception())
         return {PIPE_IN: to_browser_read, PIPE_OUT: from_browser_write}
 
+    def _write_prompt_answers(self) -> None:
+        """Its profile's preferences, which it reads as it starts, denying location and notification prompts or
+        leaving them to ask, as the deploy's settings say."""
+        preferences = self.profile_dir() / "Default" / "Preferences"
+        try:
+            current = json.loads(preferences.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            current = {}
+        current = current if isinstance(current, dict) else {}
+        defaults = current.setdefault("profile", {}).setdefault("default_content_setting_values", {})
+        for name in ("geolocation", "notifications"):
+            if getattr(self.settings, name) == "deny":
+                defaults[name] = BLOCK
+            else:
+                defaults.pop(name, None)
+        preferences.parent.mkdir(parents=True, exist_ok=True)
+        preferences.write_text(json.dumps(current), encoding="utf-8")
+
     async def _open_tabs(self, urls: list[str]) -> None:
         """Each of ``urls`` in a tab behind the active one, in order."""
         for url in urls:
@@ -247,6 +289,14 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
     def _relaunch_on_start(self) -> bool:
         return True
 
+    def _launch_running(self) -> Callable[[], Awaitable[None]]:
+        return self._open_window
+
+    async def _open_window(self) -> None:
+        """Another window, which a launch of the browser while it runs opens over its pipe: a second copy would only
+        hand its window to the first and exit, taking its new pipe with it."""
+        await self.devtools.call("Target.createTarget", {"url": "about:blank", "newWindow": True})
+
     @install_step(scope="system")
     def write_policies(self) -> None:
         """agentenv's unattended-use policies, with the subclass's over them, where its build reads them."""
@@ -286,6 +336,14 @@ def _open_web() -> bool:
     return os.environ.get(OPEN_WEB_ENV) == "1"
 
 
+def _shm_bytes(path: str = "/dev/shm") -> int:
+    try:
+        stats = os.statvfs(path)
+    except OSError:
+        return 0
+    return stats.f_frsize * stats.f_blocks
+
+
 def _headless() -> bool:
     """Alone it runs headless, but headful on Xvfb for the open web, whose sites block headless browsers."""
     return _alone() and not _open_web()

{agentenv_framework_protocol-0.1.432 → agentenv_framework_protocol-0.1.434}/tests/test_website_browser.py

@@ -1,17 +1,20 @@
 """WebsiteBrowserEnvironment: agentenv's flags after a subclass's command, in a computer and alone, and the proxy rule
 for each; a subclass refused for carrying one of them; the start tabs, the time zone and the window from its settings;
 its launch run with no desktop when alone; a CDP connection over a new debugging pipe at each launch, which its ready
-check asks, and a browser launched again when its server restarts; its policies, card params and skill; and an app that
-isn't a browser launched and declared as before."""
+check asks, and a browser launched again when its server restarts; its shared memory in files only on a small
+/dev/shm; an empty cache and the deploy's prompt answers in its profile at each launch; its policies, card params and
+skill; and an app that isn't a browser launched and declared as before."""
 from __future__ import annotations
 
 import asyncio
 import json
+import os
 import sys
 
 import pytest
 
 from agentenv_protocol.computer import APP_SETTINGS_ENV, ComputerAppEnvironment, Launch, Ready, app, linux, session
+from agentenv_protocol import website_browser
 from agentenv_protocol.computer import app_runtime
 from agentenv_protocol.computer.platform import Platform
 from agentenv_protocol.website_browser import (ALONE_BYPASS, ALONE_ENV, BROWSER, COMPUTER_BYPASS, OPEN_WEB_ENV,
@@ -19,9 +22,11 @@ from agentenv_protocol.website_browser import (ALONE_BYPASS, ALONE_ENV, BROWSER,
                                                WebsiteBrowserEnvironment)
 
 PROXY = "http://127.0.0.1:3128"
-OWNED = ["--user-data-dir", "--remote-debugging-pipe", "--no-first-run", "--no-default-browser-check", "--lang=en-US"]
-# A browser that answers CDP on its debugging pipe, fds 3 and 4, as a Chromium does: Browser.getVersion with its product,
-# Target.createTarget by writing the tab's URL to tabs.txt beside it, anything else with an error.
+OWNED = ["--user-data-dir", "--disk-cache-dir", "--remote-debugging-pipe", "--no-first-run",
+         "--no-default-browser-check", "--lang=en-US"]
+# A browser that answers CDP on its debugging pipe, fds 3 and 4, as a Chromium does: Browser.getVersion with its
+# product, Target.createTarget by writing the tab's URL to tabs.txt beside it, a new window's after "window ", anything
+# else with an error.
 FAKE_BROWSER = """import json, os
 buffer = b""
 while chunk := os.read(3, 65536):
@@ -31,9 +36,9 @@ while chunk := os.read(3, 65536):
         message = json.loads(raw)
         if message["method"] == "Browser.getVersion":
             answer = {"result": {"product": "Fake/1"}}
-        elif message["method"] == "Target.createTarget" and message["params"]["background"]:
+        elif message["method"] == "Target.createTarget":
             with open("tabs.txt", "a") as tabs:
-                tabs.write(message["params"]["url"] + "\\n")
+                tabs.write(("window " if message["params"].get("newWindow") else "") + message["params"]["url"] + "\\n")
             answer = {"result": {"targetId": message["params"]["url"]}}
         else:
             answer = {"error": {"code": -32601, "message": "unknown method"}}
@@ -60,8 +65,10 @@ class OnDemandBrowser(WebsiteBrowserEnvironment):
 
 @pytest.fixture(autouse=True)
 def browser_home(monkeypatch, tmp_path):
-    """A browser on Linux, its session user's home under ``tmp_path``, inside a computer with no site proxy."""
+    """A browser on Linux, its session user's home under ``tmp_path``, inside a computer with no site proxy and 1 GiB
+    of /dev/shm."""
     monkeypatch.setattr(app, "detect", lambda: Platform(os="linux"))
+    monkeypatch.setattr(website_browser, "_shm_bytes", lambda path="/dev/shm": 1 << 30)
     monkeypatch.setenv("HOME", str(tmp_path / "home"))
     (tmp_path / "home").mkdir()
     monkeypatch.setenv("ENVIRONMENT_NAME", "chromium")
@@ -78,7 +85,8 @@ def test_in_a_computer_its_flags_follow_its_command_then_its_start_tabs_and_its_
     launch = Browser().launch
 
     profile = f"--user-data-dir={browser_home / '.config/chromium'}"
-    assert launch.command == ["chromium/chrome", "--no-sandbox", profile, *OWNED[1:], "about:blank"]
+    cache = f"--disk-cache-dir={browser_home / '.cache/chromium'}"
+    assert launch.command == ["chromium/chrome", "--no-sandbox", profile, cache, *OWNED[2:], "about:blank"]
     assert launch.env == {"TZ": "UTC"}
     assert launch.window == {"class": "Chromium"} and launch.ready == Ready(window=True, timeout_s=30)
 
@@ -89,7 +97,7 @@ def test_in_a_computer_with_a_site_proxy_only_loopback_bypasses_it(monkeypatch):
     command = Browser().launch.command
 
     assert [f"--proxy-server={PROXY}", f"--proxy-bypass-list={COMPUTER_BYPASS}",
-            "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"] == command[7:10]
+            "--force-webrtc-ip-handling-policy=disable_non_proxied_udp"] == command[8:11]
     assert not any(flag.startswith(("--headless", "--window-size")) for flag in command)
 
 
@@ -142,7 +150,8 @@ def test_alone_it_refuses_to_launch_without_a_site_proxy(monkeypatch):
 
 
 @pytest.mark.parametrize("flag", ["--remote-debugging-port=9222", "--remote-allow-origins=*", "--headless",
-                                  "--proxy-server=http://elsewhere:3128", "--user-data-dir=/tmp/profile"])
+                                  "--proxy-server=http://elsewhere:3128", "--user-data-dir=/tmp/profile",
+                                  "--disk-cache-dir=/tmp/cache", "--disable-dev-shm-usage"])
 def test_a_subclass_whose_command_carries_a_flag_agentenv_owns_is_refused_when_declared(flag):
     @linux(launch=Launch(command=["chromium/chrome", flag]))
     class Widened(WebsiteBrowserEnvironment):
@@ -152,6 +161,37 @@ def test_a_subclass_whose_command_carries_a_flag_agentenv_owns_is_refused_when_d
         Widened.declaration()
 
 
+@pytest.mark.parametrize("mib, in_files", [(64, True), (1024, False)], ids=["docker-default", "sized"])
+def test_it_keeps_its_shared_memory_in_files_only_when_dev_shm_is_under_1_gib(monkeypatch, mib, in_files):
+    monkeypatch.setattr(website_browser, "_shm_bytes", lambda path="/dev/shm": mib * 2**20)
+
+    assert ("--disable-dev-shm-usage" in Browser().launch.command) is in_files
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("settings, prompts", [
+    ({}, {"geolocation": 2, "notifications": 2}),
+    ({"notifications": "ask"}, {"geolocation": 2}),
+], ids=["deny", "ask"])
+async def test_each_launch_starts_with_an_empty_cache_and_the_deploys_prompt_answers_in_its_profile(
+        browser_home, monkeypatch, settings, prompts):
+    _settings(monkeypatch, **settings)
+    preferences = browser_home / ".config/chromium/Default/Preferences"
+    preferences.parent.mkdir(parents=True)
+    preferences.write_text(json.dumps({"homepage": "about:blank", "profile": {"default_content_setting_values": {
+        "notifications": 1, "cookies": 1}}}))
+    (browser_home / ".cache/chromium/Cache").mkdir(parents=True)
+    browser = Browser()
+
+    for fd in (await browser._launch_fds()).values():
+        os.close(fd)
+    browser.devtools.close()
+
+    assert json.loads(preferences.read_text()) == {"homepage": "about:blank", "profile": {
+        "default_content_setting_values": {"cookies": 1, **prompts}}}
+    assert not (browser_home / ".cache/chromium").exists()
+
+
 def test_its_settings_give_its_start_tabs_language_and_time_zone_and_no_start_url_is_a_flag(monkeypatch):
     _settings(monkeypatch, start_urls=["https://slack.com", "https://linear.app"], locale="fr-FR",
               time_zone="Europe/Paris")
@@ -242,6 +282,26 @@ async def test_each_launch_gets_a_new_pipe_its_server_talks_cdp_over_and_its_rea
     assert "devtools_answers" in runtime.ready_checks
 
 
+@pytest.mark.asyncio
+async def test_a_launch_while_it_runs_opens_a_window_over_its_pipe_and_starts_no_second_copy(monkeypatch, tmp_path,
+                                                                                             browser_home):
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(app_runtime, "LAUNCHED", tmp_path / "launched")
+    browser = FakeBrowser()
+    runtime = browser._computer_app
+
+    first = await runtime.launch_app()
+    (browser_home / ".cache/chromium").mkdir(parents=True, exist_ok=True)
+    (browser_home / ".cache/chromium/kept").touch()
+    second = await runtime.launch_app()
+    answers = await browser.devtools_answers()
+    await runtime.stop_app()
+    browser.devtools.close()
+
+    assert second == first and answers is True and (browser_home / ".cache/chromium/kept").exists()
+    assert (tmp_path / "tabs.txt").read_text().splitlines() == ["window about:blank"]
+
+
 @pytest.mark.asyncio
 async def test_headless_it_opens_one_start_tab_from_its_command_line_and_the_rest_over_its_pipe(monkeypatch, tmp_path):
     monkeypatch.chdir(tmp_path)
@@ -356,6 +416,7 @@ def test_an_app_that_isnt_a_browser_launches_and_declares_as_before():
     stored = Mail.declaration().model_dump(mode="json", exclude_none=True)
 
     assert mail.launch is Mail._installs["linux"].launch and mail._computer_app.desktop is True
+    assert mail._computer_app.launch_running is None
     assert stored["os"]["linux"]["launch"] == {"at": "boot", "command": ["mail"], "window": {"class": "Mail"},
                                                "ready": {"window": True, "timeout_s": 60.0}}