agentenv-framework-protocol 0.1.433__tar.gz → 0.1.435__tar.gz

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.433
+Version: 0.1.435
 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,15 @@ 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`; `geolocation` and
+  `notifications`, `deny` (the default), which answers a page's prompt for it, or `ask`; and `dialogs`, who
+  answers a page's JavaScript dialogs: `agent` (the default), or agentenv, accepting (`accept`, a `prompt()`
+  with its default text) or dismissing (`dismiss`) each. Either way agentenv leaves a page that asks before
+  it's left (`beforeunload`), so none of its answers blocks a navigation.
+- **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 +829,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,9 +842,22 @@ 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.
-- **`browser/v1`** on its card, params only: `chromium` (its `version`), `clock: "real"` and, alone,
-  `window`.
+  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.
+- **Its control connection**, `self.control`, a `BrowserControl` over the pipe. At each launch it attaches
+  to every page with flattened sessions and keeps a record, `since` its server started: open tabs in
+  opened order, the one whose page has focus `active`; `closed_tabs`, each with `closed_at` and
+  `closed_by` (`agentenv`, over this connection; `unknown`, anyone else; `exit` or `stop`, when the browser
+  ended on its own or its server stopped it); `downloads`, into `~/Downloads`, each with its state
+  and, completed, its size and sha256; and `dialogs`, each with its type, message, answer and who gave it.
+  `hidden_page()` gives agentenv a page of its own for reading state, in no window and never in the record.
+- **`browser/v1`** on its card: `chromium` (its `version`), `clock: "real"` and, alone, `window`; and
+  `record` (GET), framework-only, which returns that record with `launches`, the app server's log of each
+  launch (with its cause: `boot`, `server_restart`, `launch`, `data/add` or `data/reset`), each stop it made
+  and each exit it didn't, with its exit `code` or the `signal` that ended it, since the computer booted.
+  Nothing relaunches a browser that exits on its own: in a computer the agent can, and alone it's an infra
+  failure, its ready check false.
 - **Its skill**: sites by their real names, files to upload in `~/Uploads` and downloads in
   `~/Downloads`, folders it makes.
 

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/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,15 @@ 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`; `geolocation` and
+  `notifications`, `deny` (the default), which answers a page's prompt for it, or `ask`; and `dialogs`, who
+  answers a page's JavaScript dialogs: `agent` (the default), or agentenv, accepting (`accept`, a `prompt()`
+  with its default text) or dismissing (`dismiss`) each. Either way agentenv leaves a page that asks before
+  it's left (`beforeunload`), so none of its answers blocks a navigation.
+- **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 +773,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,9 +786,22 @@ 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.
-- **`browser/v1`** on its card, params only: `chromium` (its `version`), `clock: "real"` and, alone,
-  `window`.
+  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.
+- **Its control connection**, `self.control`, a `BrowserControl` over the pipe. At each launch it attaches
+  to every page with flattened sessions and keeps a record, `since` its server started: open tabs in
+  opened order, the one whose page has focus `active`; `closed_tabs`, each with `closed_at` and
+  `closed_by` (`agentenv`, over this connection; `unknown`, anyone else; `exit` or `stop`, when the browser
+  ended on its own or its server stopped it); `downloads`, into `~/Downloads`, each with its state
+  and, completed, its size and sha256; and `dialogs`, each with its type, message, answer and who gave it.
+  `hidden_page()` gives agentenv a page of its own for reading state, in no window and never in the record.
+- **`browser/v1`** on its card: `chromium` (its `version`), `clock: "real"` and, alone, `window`; and
+  `record` (GET), framework-only, which returns that record with `launches`, the app server's log of each
+  launch (with its cause: `boot`, `server_restart`, `launch`, `data/add` or `data/reset`), each stop it made
+  and each exit it didn't, with its exit `code` or the `signal` that ended it, since the computer booted.
+  Nothing relaunches a browser that exits on its own: in a computer the agent can, and alone it's an infra
+  failure, its ready check false.
 - **Its skill**: sites by their real names, files to upload in `~/Uploads` and downloads in
   `~/Downloads`, folders it makes.
 

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/pyproject.toml

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

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/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.433 → agentenv_framework_protocol-0.1.435}/src/agentenv_protocol/computer/app_data.py

@@ -15,7 +15,7 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from ..agent_env_environment import OP_ADD_DATA, OP_GET_DATA, OP_RESET_DATA
 from ..transfers import WriteNamespaceGrant
-from ..types import FilePart, uploaded_object_path
+from ..types import METHOD_ADD, METHOD_RESET, FilePart, uploaded_object_path
 from .dataplane import file_parts, part_bytes
 
 if TYPE_CHECKING:
@@ -23,6 +23,8 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+#: The cause a launch after each data call logs.
+_CAUSES = {OP_ADD_DATA: METHOD_ADD, OP_RESET_DATA: METHOD_RESET}
 #: Where an app's server keeps its paths as installed, in the app's folder.
 INITIAL = Path(".agentenv/initial")
 
@@ -80,7 +82,7 @@ class AppDataPlane:
                 raise
             finally:
                 if running:
-                    await self.runtime.launch_app()
+                    await self.runtime.launch_app(_CAUSES[op])
         except Exception as e:
             if not answer.done():
                 answer.set_exception(e)

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/src/agentenv_protocol/computer/app_runtime.py

@@ -5,10 +5,13 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import json
 import os
 import shlex
+import signal
 import time
 from collections.abc import Awaitable, Callable
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -26,6 +29,11 @@ CHECK_TIMEOUT_S = 10.0
 #: Where an app's server keeps the pid of the app it launched last, in the app's folder, so a server that restarts can
 #: still stop it.
 PID = Path(".agentenv/app.pid")
+#: Where an app's server logs each launch, stop and exit of the app, beside its pid; a boot starts the app's folder as
+#: its image has it, so the log is the boot's.
+LAUNCHES = Path(".agentenv/launches")
+#: How long an app that ended on its own may take to be reaped, for its exit code.
+EXIT_WAIT_S = 5.0
 #: How long a stopped app may take to exit before it's killed.
 STOP_TIMEOUT_S = 10.0
 
@@ -50,13 +58,16 @@ 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.exits: set[asyncio.Future] = set()
         self.started = time.time()
         self.launch_failed: Optional[str] = None
         self.checking: dict[str, asyncio.Future] = {}
@@ -78,13 +89,17 @@ class AppRuntime:
             try:
                 if relaunch:
                     await self.stop_app()
-                await self.launch_app()
+                await self.launch_app("server_restart" if relaunch else "boot")
             except Exception as e:
                 self.launch_failed = f"{type(e).__name__}: {e}"
 
-    async def launch_app(self) -> int:
+    async def launch_app(self, cause: str = "launch") -> 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, and logged with ``cause``; 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(),
@@ -98,6 +113,7 @@ class AppRuntime:
         PID.write_text(str(pid))
         _mark().parent.mkdir(parents=True, exist_ok=True)
         _mark().touch()
+        self.log("launch", pid, cause=cause)
         return pid
 
     async def stop_app(self) -> bool:
@@ -109,9 +125,39 @@ class AppRuntime:
         PID.unlink()
         if not session.alive(pid):
             return False
+        self.log("stop", pid)
         await session.stop(pid, STOP_TIMEOUT_S)
         return True
 
+    def exited(self) -> bool:
+        """Log that the app this server launched last ended on its own, with its exit code or the signal that ended
+        it, unless the server stopped it; whether it did."""
+        if (pid := _recorded_pid()) is None:
+            return False
+        noting = asyncio.ensure_future(self._log_exit(pid))
+        self.exits.add(noting)
+        noting.add_done_callback(self.exits.discard)
+        return True
+
+    async def _log_exit(self, pid: int) -> None:
+        code = await session.returncode(pid, EXIT_WAIT_S)
+        self.log("exit", pid, **({} if code is None else
+                                 {"signal": signal.Signals(-code).name} if code < 0 else {"code": code}))
+
+    def log(self, event: str, pid: int, **fields: Any) -> None:
+        """Append ``event`` for the app's ``pid`` to its launch log, which outlives its server for the boot."""
+        entry = {"at": datetime.now(timezone.utc).isoformat(), "event": event, "pid": pid, **fields}
+        _log().parent.mkdir(parents=True, exist_ok=True)
+        with _log().open("a", encoding="utf-8") as log:
+            log.write(json.dumps(entry) + "\n")
+
+    def launches(self) -> list[dict]:
+        """Every launch, stop and exit of the app since the computer booted, in order."""
+        try:
+            return [json.loads(line) for line in _log().read_text(encoding="utf-8").splitlines() if line]
+        except FileNotFoundError:
+            return []
+
     async def readiness(self) -> AppReadiness:
         ready = self.launch.ready if self.launch is not None else None
         checks: list[tuple[str, Awaitable[Optional[str]]]] = []
@@ -148,6 +194,17 @@ def _mark() -> Path:
     return LAUNCHED / Path.cwd().name
 
 
+def _log() -> Path:
+    return LAUNCHES
+
+
+def _recorded_pid() -> Optional[int]:
+    try:
+        return int(PID.read_text())
+    except (FileNotFoundError, ValueError):
+        return None
+
+
 def _launched_at() -> Optional[float]:
     """When the app was last launched since the computer booted, by its mark."""
     try:
@@ -156,6 +213,12 @@ def _launched_at() -> Optional[float]:
         return None
 
 
+def _running() -> Optional[int]:
+    """The pid of the app this server launched last, while it runs."""
+    pid = _recorded_pid()
+    return pid if pid is not None and 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.433 → agentenv_framework_protocol-0.1.435}/src/agentenv_protocol/computer/dataplane.py

@@ -15,7 +15,7 @@ import httpx
 from pydantic import TypeAdapter, ValidationError
 
 from ..agent_env_environment import add_data, get_data
-from ..transfers import NamespaceUploader, ReadObject, RelativePath, WriteNamespaceGrant, download
+from ..transfers import NamespaceUploader, ReadObject, RelativePath, TransferError, WriteNamespaceGrant, download
 from ..types import DATA_OBJECTS_EXTENSION_URI, FilePart, FileWithBytes, FileWithUri, uploaded_file_part, uploaded_object_path
 
 if TYPE_CHECKING:
@@ -64,22 +64,31 @@ class DataPlane:
 async def file_parts(home: Path, paths: list[str], write_namespace: Optional[WriteNamespaceGrant],
                      leaving_out: list[str] = ()) -> list:
     """A part for each file under ``paths`` of ``home`` but under none of ``leaving_out``, naming its path relative to
-    ``home``: uploaded under ``write_namespace`` when there is one, else inline."""
+    ``home``: uploaded under ``write_namespace`` when there is one, else inline. A file a running app removes before it's
+    read is left out."""
     files = [(relative, source) for relative, source in _data_files(home, paths)
              if not any(PurePosixPath(relative).is_relative_to(owned) for owned in leaving_out)]
+    parts = []
     if write_namespace is not None:
         uploader = NamespaceUploader(write_namespace)
-        parts = []
         for relative, source in files:
-            await uploader.upload(relative, source)
+            try:
+                await uploader.upload(relative, source)
+            except (TransferError, OSError):
+                if source.exists():
+                    raise
+                continue
             parts.append(uploaded_file_part(relative, name=source.name, mime_type=_mime(source)))
         return parts
-    return [
-        FilePart(file=FileWithBytes(bytes=base64.b64encode(source.read_bytes()).decode("ascii"),
-                                    name=source.name, mimeType=_mime(source)),
-                 metadata={DATA_OBJECTS_EXTENSION_URI: {"path": relative}})
-        for relative, source in files
-    ]
+    for relative, source in files:
+        try:
+            data = source.read_bytes()
+        except FileNotFoundError:
+            continue
+        parts.append(FilePart(file=FileWithBytes(bytes=base64.b64encode(data).decode("ascii"), name=source.name,
+                                                 mimeType=_mime(source)),
+                              metadata={DATA_OBJECTS_EXTENSION_URI: {"path": relative}}))
+    return parts
 
 
 async def part_bytes(part: FilePart) -> bytes:

{agentenv_framework_protocol-0.1.433 → agentenv_framework_protocol-0.1.435}/src/agentenv_protocol/computer/session.py

@@ -17,6 +17,10 @@ POLL_S = 0.2
 WITH_FDS = Path(__file__).with_name("_with_fds.py")
 #: The processes launched into the session, kept until they exit so each is reaped.
 _running: set[asyncio.Task] = set()
+#: Each launched process's reaping, by pid, until its exit is asked for: its return code, negative for a signal.
+_exits: dict[int, asyncio.Future] = {}
+#: How many exits no one has asked for are kept, the latest.
+KEPT_EXITS = 16
 
 
 async def wait_until_up() -> None:
@@ -38,12 +42,35 @@ async def launch(argv: list[str], cwd: Path, env: dict[str, str], fds: Optional[
     reaped = asyncio.ensure_future(process.wait())
     _running.add(reaped)
     reaped.add_done_callback(_running.discard)
+    _exits[process.pid] = reaped
+    reaped.add_done_callback(lambda _: _forget_old_exits())
     return process.pid
 
 
+def _forget_old_exits() -> None:
+    """Drop all but the latest ``KEPT_EXITS`` exits no one has asked for."""
+    for pid in [pid for pid, reaped in _exits.items() if reaped.done()][:-KEPT_EXITS]:
+        del _exits[pid]
+
+
+async def returncode(pid: int, timeout_s: float) -> Optional[int]:
+    """The return code the process ``launch`` started as ``pid`` exited with, negative for the signal that ended it,
+    once it's reaped within ``timeout_s``; None for one ``launch`` didn't start or that hasn't exited."""
+    reaped = _exits.get(pid)
+    if reaped is None:
+        return None
+    try:
+        code = await asyncio.wait_for(asyncio.shield(reaped), timeout_s)
+    except TimeoutError:
+        return None
+    _exits.pop(pid, None)
+    return code
+
+
 async def stop(pid: int, timeout_s: float) -> None:
     """End the session ``launch`` started as ``pid``, every process in it: asked to exit, then killed after
-    ``timeout_s``."""
+    ``timeout_s``. No one asks how it exited once it's stopped."""
+    _exits.pop(pid, None)
     try:
         os.killpg(pid, signal.SIGTERM)
     except ProcessLookupError: