Puppeteer/Playwright cache_dir: drop env-var fallback, go passthrough when install_root=None

``cache_dir`` is now a tiny computed helper that returns
``<install_root>/cache`` when ``install_root`` is pinned and ``None``
otherwise — no env-var fallback. This flips the ``install_root=None``
mode to pure passthrough:

- The caller's ambient ``PUPPETEER_CACHE_DIR`` /
  ``PLAYWRIGHT_BROWSERS_PATH`` passes through to every subprocess
  unchanged (abxpkg exports nothing of its own).
- ``load()`` trusts whatever ``puppeteer-browsers list`` /
  playwright-core ``executablePath()`` reports — no scoping applied.
- ``uninstall()`` is a no-op when ``install_root=None``: we refuse to
  rmtree the user's cache because we don't own it. Users who want
  managed uninstall should set ``install_root``; users who stay in
  ambient mode manage their own cache via the CLI or their own tooling.
- ``install()`` only passes ``--path=`` / sets
  ``PLAYWRIGHT_BROWSERS_PATH`` when we own the root; otherwise the
  CLIs install into their own default.

Every existing call site already guarded on ``self.cache_dir is not
None``, so dropping the env-var branch changes no managed-mode
behaviour — it just stops abxpkg from claiming ownership of a cache
dir the user controls.

Author: claude

README.md

@@ -1078,7 +1078,7 @@ 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`: `cache_dir` is a computed property. When `install_root` is pinned it's always `<install_root>/cache`. When `install_root` is unset it reads the ambient `$PUPPETEER_CACHE_DIR` env var so ``load()`` / ``uninstall()`` / scope checks target the same directory the user configured externally (``None`` when the env var is also unset — puppeteer-browsers then falls back to `~/.cache/puppeteer`). The resolved `cache_dir` is exported as `PUPPETEER_CACHE_DIR` to every subprocess the provider runs.
+- Cache dir: `cache_dir` is a computed helper property. When `install_root` is pinned it's `<install_root>/cache` and abxpkg owns it — exported as `PUPPETEER_CACHE_DIR` to every subprocess, used for `--path=` on `puppeteer-browsers install` / `list`, and rmtree'd per-browser on `uninstall()`. When `install_root` is unset, `cache_dir` is `None`: the provider is in pure passthrough mode. The caller's ambient `$PUPPETEER_CACHE_DIR` (or the CLI's `~/.cache/puppeteer` default) flows through to subprocesses unchanged, `load()` trusts whatever path `puppeteer-browsers list` reports, and `uninstall()` is a no-op — we don't touch the user's own cache.
 - 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.
@@ -1102,7 +1102,7 @@ euid = 0                         # routes exec() through sudo-first-then-fallbac
 ```
 
 - 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`: `cache_dir` is a computed property. When `install_root` is pinned it's always `<install_root>/cache`. When `install_root` is unset it reads the ambient `$PLAYWRIGHT_BROWSERS_PATH` env var so ``load()`` / ``uninstall()`` / scope checks target the same directory the user configured externally (``None`` when the env var is also unset — playwright then falls back to `~/.cache/ms-playwright` on Linux). The resolved `cache_dir` is exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess (including the `env KEY=VAL -- ...` wrapper used when we go through sudo). `uninstall()` deletes matching `<browser>-*/` dirs from the resolved `cache_dir` — and when neither `install_root` nor `$PLAYWRIGHT_BROWSERS_PATH` is set, it touches nothing, leaving playwright's OS-default cache alone.
+- Cache dir: `cache_dir` is a computed helper property. When `install_root` is pinned it's `<install_root>/cache` and abxpkg owns it — exported as `PLAYWRIGHT_BROWSERS_PATH` to every subprocess (including the `env KEY=VAL -- ...` wrapper used when we go through sudo), used to scope `executablePath()` hits on `load()`, and walked for per-browser rmtree on `uninstall()`. When `install_root` is unset, `cache_dir` is `None`: the provider is in pure passthrough mode. The caller's ambient `$PLAYWRIGHT_BROWSERS_PATH` (or playwright's `~/.cache/ms-playwright` default on Linux) flows through to subprocesses unchanged, `load()` trusts whatever path `executablePath()` reports, and `uninstall()` is a no-op — we don't touch the user's own cache.
 - 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

@@ -80,23 +80,19 @@ class PlaywrightProvider(BinProvider):
     @computed_field
     @property
     def cache_dir(self) -> Path | None:
-        """Where browser downloads land.
-
-        When ``install_root`` is pinned we always use
-        ``<install_root>/cache``. When ``install_root`` is unset we fall
-        back to the caller's ``PLAYWRIGHT_BROWSERS_PATH`` env var
-        (playwright's native convention) so ``load``/``uninstall``/
-        scope checks all target the same directory the user already
-        configured externally. When neither is set we return ``None``
-        and let playwright pick its own default
-        (``~/.cache/ms-playwright`` on Linux etc.).
+        """``<install_root>/cache`` when managed, else ``None``.
+
+        Internal helper for the install/uninstall/load sites. When
+        ``install_root`` is unset we stay out of the way: the ambient
+        ``PLAYWRIGHT_BROWSERS_PATH`` (or playwright's
+        ``~/.cache/ms-playwright`` default) passes through to
+        subprocesses untouched, ``default_abspath_handler`` trusts
+        whatever path ``executablePath()`` reports, and
+        ``default_uninstall_handler`` skips rmtree of the user's cache.
         """
-        if self.install_root is not None:
-            return self.install_root / "cache"
-        env_override = os.environ.get("PLAYWRIGHT_BROWSERS_PATH")
-        if env_override:
-            return Path(env_override).expanduser()
-        return None
+        if self.install_root is None:
+            return None
+        return self.install_root / "cache"
 
     @computed_field
     @property

abxpkg/binprovider_puppeteer.py

@@ -70,28 +70,22 @@ class PuppeteerProvider(BinProvider):
     @computed_field
     @property
     def cache_dir(self) -> Path | None:
-        """Where browser downloads land.
-
-        When ``install_root`` is pinned we always use
-        ``<install_root>/cache``. When ``install_root`` is unset we fall
-        back to the caller's ``PUPPETEER_CACHE_DIR`` env var (the
-        puppeteer-browsers native convention) so ``load``/``uninstall``/
-        scope checks all target the same directory the user already
-        configured externally. When neither is set we return ``None``
-        and let puppeteer-browsers pick its own default
-        (``~/.cache/puppeteer``).
+        """``<install_root>/cache`` when managed, else ``None``.
+
+        Internal helper for the install/uninstall/load sites. When
+        ``install_root`` is unset we stay out of the way: the ambient
+        ``PUPPETEER_CACHE_DIR`` (or the CLI's ``~/.cache/puppeteer``
+        default) passes through to subprocesses untouched, and we
+        refuse to rmtree anything in the user's cache on ``uninstall``.
         """
-        if self.install_root is not None:
-            return self.install_root / "cache"
-        env_override = os.environ.get("PUPPETEER_CACHE_DIR")
-        if env_override:
-            return Path(env_override).expanduser()
-        return None
+        if self.install_root is None:
+            return None
+        return self.install_root / "cache"
 
     @computed_field
     @property
     def ENV(self) -> "dict[str, str]":
-        if not self.cache_dir:
+        if self.cache_dir is None:
             return {}
         return {"PUPPETEER_CACHE_DIR": str(self.cache_dir)}