Puppeteer/Playwright: drop cache_dir field, derive purely from install_root

Per maintainer feedback: ``cache_dir`` was always 1:1 with
``install_root``, so the writable field was redundant. Collapse it
to a single ``@computed_field`` on both providers:

    cache_dir = <install_root>/cache  when install_root is set
    cache_dir = None                  when install_root is unset

When ``install_root`` is unset the provider exports neither
``PUPPETEER_CACHE_DIR`` nor ``PLAYWRIGHT_BROWSERS_PATH`` to
subprocesses, so ``puppeteer-browsers`` / ``playwright`` fall back to
whatever the ambient env + their own OS default dictates. When
``install_root`` is pinned, the computed ``cache_dir`` flows through
to ``ENV``, the sudo ``env KEY=VAL`` wrapper, ``--path=...``
install args, ``default_uninstall_handler``, and
``default_abspath_handler`` scope checks — all call sites already
guarded on ``is not None`` so removing the field changes no behaviour
when install_root is set.

Provider field surface is now just ``install_root`` + ``bin_dir``
(plus the class-level ``INSTALLER_BIN`` constant), matching the
maintainer's "only install_root, cache_dir, bin_dir; no duplicates"
direction.

Author: claude

README.md

@@ -1074,11 +1074,11 @@ INSTALLER_BIN = "puppeteer-browsers"
 PATH = ""
 install_root = $ABXPKG_PUPPETEER_ROOT or $ABXPKG_LIB_DIR/puppeteer
 bin_dir = <install_root>/bin
-cache_dir = <install_root>/cache  # hydrated from PUPPETEER_CACHE_DIR env when install_root is unset
+cache_dir = <install_root>/cache  # computed; None when install_root is unset
 ```
 
 - Install root: set `install_root` for the root dir and `bin_dir` for symlinked executables. Leave it unset for ambient/global mode, where cache ownership stays with the host and `INSTALLER_BINARY` must already be resolvable from the ambient provider set.
-- Cache dir / `PUPPETEER_CACHE_DIR`: browser downloads land in `cache_dir`, resolved with four-tier precedence at validate time: explicit `cache_dir` kwarg wins → else `PUPPETEER_CACHE_DIR` env var → else `<install_root>/cache` when an install root is pinned → else `None`. The resolved value is exported as `PUPPETEER_CACHE_DIR` to every subprocess the provider runs.
+- Cache dir / `PUPPETEER_CACHE_DIR`: `cache_dir` is a computed property — it's always `<install_root>/cache` when `install_root` is pinned (and exported as `PUPPETEER_CACHE_DIR` to every subprocess), and `None` otherwise. When `install_root` is unset, abxpkg exports nothing and `puppeteer-browsers` falls back to its own default (`$PUPPETEER_CACHE_DIR` from the ambient env, otherwise `~/.cache/puppeteer`).
 - Auto-switching: bootstraps `@puppeteer/browsers` through `NpmProvider` and then uses that CLI for browser installs.
 - `dry_run`: shared behavior.
 - Security: `min_release_age` is unsupported for browser installs and is ignored with a warning if explicitly requested. `postinstall_scripts=False` is supported for the underlying npm bootstrap path, and `ABXPKG_POSTINSTALL_SCRIPTS` hydrates the provider default here.
@@ -1097,12 +1097,12 @@ INSTALLER_BIN = "playwright"
 PATH = ""
 install_root = None              # abxpkg-managed root dir for bin_dir / nested npm prefix
 bin_dir = <install_root>/bin     # symlink dir for resolved browsers
-cache_dir = <install_root>/cache # hydrated from PLAYWRIGHT_BROWSERS_PATH env when install_root is unset
+cache_dir = <install_root>/cache # computed; None when install_root is unset
 euid = 0                         # routes exec() through sudo-first-then-fallback
 ```
 
 - Install root: set `install_root` to pin the abxpkg-managed root dir (where `bin_dir` symlinks and the nested npm prefix live). Leave it unset to let playwright use its own OS-default browsers path (`~/.cache/ms-playwright` on Linux etc.) — in that case abxpkg maintains no symlink dir or npm prefix at all, the `playwright` npm CLI bootstraps against the host's npm default, and `load()` returns the resolved `executablePath()` directly. `bin_dir` overrides the symlink directory when `install_root` is pinned.
-- Cache dir / `PLAYWRIGHT_BROWSERS_PATH`: browser downloads land in `cache_dir`, resolved with four-tier precedence at validate time: explicit `cache_dir` kwarg wins → else `PLAYWRIGHT_BROWSERS_PATH` env var → else `<install_root>/cache` when an install root is pinned → else `None` (let playwright pick its OS default). The final value is exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess the provider runs. `uninstall()` deletes matching `<browser>-*/` dirs from the resolved `cache_dir` (never from playwright's untouched OS-default cache when nothing is pinned).
+- Cache dir / `PLAYWRIGHT_BROWSERS_PATH`: `cache_dir` is a computed property — it's always `<install_root>/cache` when `install_root` is pinned (and exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess, including the `env KEY=VAL -- ...` wrapper used when we go through sudo), and `None` otherwise. When `install_root` is unset, abxpkg exports nothing and `playwright` falls back to its own default (`$PLAYWRIGHT_BROWSERS_PATH` from the ambient env, otherwise `~/.cache/ms-playwright` on Linux). `uninstall()` deletes matching `<browser>-*/` dirs from the resolved `cache_dir` and never touches playwright's OS-default cache when nothing is pinned.
 - Auto-switching: bootstraps the `playwright` npm package through `NpmProvider`, then runs `playwright install --with-deps <install_args>` against it. Resolves each installed browser's real executable via the `playwright-core` Node.js API (`chromium.executablePath()` etc.) and writes a symlink into `bin_dir` when one is configured.
 - `dry_run`: shared behavior — the install handler short-circuits to a placeholder without touching the host.
 - Privilege handling: `--with-deps` installs system packages and requires root on Linux. ``euid`` defaults to ``0``, which routes every ``exec()`` call through the base ``BinProvider.exec`` sudo-first-then-fallback path — it tries ``sudo -n -- playwright install --with-deps ...`` first on non-root hosts, falls back to running the command directly if sudo fails or isn't available, and merges both stderr outputs into the final error if both attempts fail.

abxpkg/binprovider_playwright.py

@@ -8,9 +8,8 @@
 import sys
 import platform
 from pathlib import Path
-from typing import Self
 
-from pydantic import Field, TypeAdapter, computed_field, model_validator
+from pydantic import Field, TypeAdapter, computed_field
 
 from .base_types import (
     BinName,
@@ -37,15 +36,14 @@ class PlaywrightProvider(BinProvider):
     ``playwright`` npm package. When ``playwright_root`` is set it acts
     as the abxpkg install root: a dedicated npm prefix is nested under
     it, ``bin_dir`` surfaces each requested browser so ``load(bin_name)``
-    finds it directly, and ``PLAYWRIGHT_BROWSERS_PATH`` defaults to
-    ``<install_root>/cache`` for the actual browser downloads. Callers
-    that want to pin the browsers path somewhere else can set the
-    ``browser_cache_dir`` field (hydrated from ``PLAYWRIGHT_BROWSERS_PATH``
-    env) — that override always wins over ``install_root/cache``.
+    finds it directly, and ``PLAYWRIGHT_BROWSERS_PATH`` is pinned to
+    ``<install_root>/cache`` for every subprocess the provider runs.
     When ``playwright_root`` is left unset, playwright picks its own
-    default browsers path, the npm CLI bootstraps against the host's
-    npm default, and ``load()`` returns the resolved ``executablePath()``
-    directly without creating any install_root/bin_dir symlinks.
+    default browsers path (``$PLAYWRIGHT_BROWSERS_PATH`` from the
+    ambient env, otherwise ``~/.cache/ms-playwright`` on Linux), the
+    npm CLI bootstraps against the host's npm default, and ``load()``
+    returns the resolved ``executablePath()`` directly without
+    creating any install_root/bin_dir symlinks.
 
     ``--with-deps`` installs system packages and requires root on
     Linux, so ``euid`` defaults to ``0``: the base ``BinProvider.exec``
@@ -73,31 +71,27 @@ class PlaywrightProvider(BinProvider):
     # Only set in managed mode: setup()/default_abspath_handler() use it to create and read
     # stable browser shims under ``<install_root>/bin``; global mode leaves it unset.
     bin_dir: Path | None = None
-    # Where browsers get downloaded. Exported as ``PLAYWRIGHT_BROWSERS_PATH``
-    # to every subprocess. Precedence at validate time:
-    #   1. explicit ``cache_dir`` kwarg wins (more-specific override)
-    #   2. else ``PLAYWRIGHT_BROWSERS_PATH`` env var wins (same semantics
-    #      for external callers invoking via env)
-    #   3. else ``<install_root>/cache`` when an install root is pinned
-    #   4. else ``None`` (global mode — let playwright pick its OS default)
-    cache_dir: Path | None = Field(
-        default_factory=lambda: (
-            Path(os.environ["PLAYWRIGHT_BROWSERS_PATH"]).expanduser()
-            if os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
-            else None
-        ),
-    )
 
     # Only Linux needs the sudo-first execution path for
     # ``playwright install --with-deps``. On macOS and elsewhere,
     # run as the normal user by default.
     euid: int | None = 0 if platform.system().lower() == "linux" else None
 
-    @model_validator(mode="after")
-    def _fill_cache_dir_from_install_root(self) -> Self:
-        if self.cache_dir is None and self.install_root is not None:
-            self.cache_dir = self.install_root / "cache"
-        return self
+    @computed_field
+    @property
+    def cache_dir(self) -> Path | None:
+        """Where browser downloads land.
+
+        When ``install_root`` is pinned we always use
+        ``<install_root>/cache`` and export it as ``PLAYWRIGHT_BROWSERS_PATH``
+        to every subprocess. When ``install_root`` is unset we leave it
+        ``None`` and let ``playwright`` fall back to its own default
+        (``$PLAYWRIGHT_BROWSERS_PATH`` from the ambient env, otherwise
+        ``~/.cache/ms-playwright`` on Linux etc.).
+        """
+        if self.install_root is not None:
+            return self.install_root / "cache"
+        return None
 
     @computed_field
     @property

abxpkg/binprovider_puppeteer.py

@@ -66,20 +66,22 @@ class PuppeteerProvider(BinProvider):
     # Only set in managed mode: setup()/default_abspath_handler() use it to expose stable
     # browser launch shims under ``<install_root>/bin``; global mode leaves it unset.
     bin_dir: Path | None = None
-    # Where browsers get downloaded. Precedence at validate time:
-    #   1. explicit ``cache_dir`` kwarg wins (more-specific override)
-    #   2. else ``PUPPETEER_CACHE_DIR`` env var wins (same semantics for
-    #      external callers invoking via env)
-    #   3. else ``<install_root>/cache`` when an install root is pinned
-    #   4. else ``None`` (global mode — let puppeteer-browsers pick its
-    #      own default cache)
-    cache_dir: Path | None = Field(
-        default_factory=lambda: (
-            Path(os.environ["PUPPETEER_CACHE_DIR"]).expanduser()
-            if os.environ.get("PUPPETEER_CACHE_DIR")
-            else None
-        ),
-    )
+
+    @computed_field
+    @property
+    def cache_dir(self) -> Path | None:
+        """Where browser downloads land.
+
+        When ``install_root`` is pinned we always use
+        ``<install_root>/cache`` and export it as ``PUPPETEER_CACHE_DIR``
+        to every subprocess. When ``install_root`` is unset we leave it
+        ``None`` and let ``puppeteer-browsers`` fall back to its own
+        default (``$PUPPETEER_CACHE_DIR`` from the ambient env, otherwise
+        ``~/.cache/puppeteer``).
+        """
+        if self.install_root is not None:
+            return self.install_root / "cache"
+        return None
 
     @computed_field
     @property
@@ -95,8 +97,6 @@ def supports_postinstall_disable(self, action, no_cache: bool = False) -> bool:
     def detect_euid_to_use(self) -> Self:
         if self.bin_dir is None and self.install_root is not None:
             self.bin_dir = self.install_root / "bin"
-        if self.cache_dir is None and self.install_root is not None:
-            self.cache_dir = self.install_root / "cache"
         return self
 
     def setup_PATH(self, no_cache: bool = False) -> None: