Puppeteer/Playwright uninstall: resolve path via load() then rmtree

``puppeteer-browsers clear`` wipes the whole cache (no per-browser
filter) and ``playwright uninstall`` rejects browser-name arguments,
so neither CLI can do the per-browser uninstall abxpkg exposes.

Switch both uninstall handlers to:

1. ``self.load(bin_name, no_cache=True)`` — playwright-core's
   ``executablePath()`` / puppeteer-browsers' ``list`` already read
   the right path from the subprocess env, so load() handles all
   three cases uniformly:
     - managed ``install_root`` → abxpkg exports the env var itself
     - unmanaged default       → CLI's own OS default
     - custom ``PUPPETEER_CACHE_DIR`` / ``PLAYWRIGHT_BROWSERS_PATH`` →
       ambient env passes through via ``build_exec_env``
2. Walk up from the resolved abspath to find the browser's top-level
   dir (``<cache>/<browser_name>/`` for puppeteer,
   ``<cache>/<browser_name>-<buildId>/`` for playwright) and rmtree
   it.

No more ``self.cache_dir`` lookups in either uninstall handler, and
the existing ``bin_dir`` symlink cleanup still runs first so ``load``
stops resolving a stale shim if rmtree fails partway through.

Author: claude

abxpkg/binprovider_playwright.py

@@ -739,23 +739,32 @@ def default_uninstall_handler(
         install_args: InstallArgs | None = None,
         **context,
     ) -> bool:
-        # Drop the symlink first (if we're managing one) so ``load()``
-        # stops seeing the tool even if browser dir removal partially
-        # fails.
+        # Drop the managed shim first so ``load()`` stops returning the
+        # symlink even if the browser-dir rmtree partially fails.
         if self.bin_dir is not None:
             (self.bin_dir / bin_name).unlink(missing_ok=True)
 
-        # ``playwright uninstall`` only removes *unused* browsers from
-        # the entire host, so drop the matching directories ourselves
-        # from the resolved ``cache_dir`` (= ``PLAYWRIGHT_BROWSERS_PATH``).
-        # Only touch it if the caller pinned one explicitly or via
-        # ``install_root`` — we don't delete from playwright's own
-        # OS-default cache.
-        if self.cache_dir is not None and self.cache_dir.is_dir():
-            for entry in self.cache_dir.iterdir():
-                if entry.is_dir() and entry.name.startswith(f"{bin_name}-"):
-                    logger.info("$ %s", format_command(["rm", "-rf", str(entry)]))
-                    shutil.rmtree(entry, ignore_errors=True)
+        # Use ``load()`` to resolve the actual installed browser
+        # executable — ``playwright-core``'s ``executablePath()`` reads
+        # ``PLAYWRIGHT_BROWSERS_PATH`` from the subprocess env, which
+        # the provider exports when ``install_root`` is set and which
+        # otherwise passes through from the ambient env. This single
+        # call covers managed, OS-default, and user-env-var modes.
+        # Then walk up from that abspath to find the
+        # ``<bin_name>-<buildId>/`` dir and rmtree it — playwright's
+        # own ``uninstall`` CLI has no per-browser argument, so this
+        # is still the only way to remove a specific browser.
+        try:
+            loaded = self.load(bin_name, quiet=True, no_cache=True)
+        except Exception:
+            loaded = None
+        loaded_abspath = loaded.loaded_abspath if loaded else None
+        if loaded_abspath is not None:
+            for parent in Path(loaded_abspath).resolve().parents:
+                if parent.name.startswith(f"{bin_name}-"):
+                    logger.info("$ %s", format_command(["rm", "-rf", str(parent)]))
+                    shutil.rmtree(parent, ignore_errors=True)
+                    break
         return True
 
 

abxpkg/binprovider_puppeteer.py

@@ -699,16 +699,31 @@ def default_uninstall_handler(
         install_args: InstallArgs | None = None,
         **context,
     ) -> bool:
-        install_args = list(install_args or self.get_install_args(bin_name))
-        browser_name = self._browser_name(bin_name, install_args)
+        # Drop the managed shim first so ``load()`` stops returning the
+        # symlink even if the browser-dir rmtree partially fails.
         if self.bin_dir is not None:
             bin_path = self.bin_dir / bin_name
             if bin_path.exists() or bin_path.is_symlink():
                 logger.info("$ %s", format_command(["rm", "-f", str(bin_path)]))
             bin_path.unlink(missing_ok=True)
-        if self.cache_dir is not None:
-            browser_dir = self.cache_dir / browser_name
-            if browser_dir.exists():
-                logger.info("$ %s", format_command(["rm", "-rf", str(browser_dir)]))
-                shutil.rmtree(browser_dir, ignore_errors=True)
+
+        # Use ``load()`` to resolve the actual installed browser
+        # executable — load honours managed install_root, the ambient
+        # PUPPETEER_CACHE_DIR env var, and puppeteer-browsers' own
+        # default, so this single call handles all three cases. Then
+        # walk up from that abspath to find the browser's top-level
+        # directory (``<cache>/<browser_name>/``) and rmtree it.
+        install_args = list(install_args or self.get_install_args(bin_name))
+        browser_name = self._browser_name(bin_name, install_args)
+        try:
+            loaded = self.load(bin_name, quiet=True, no_cache=True)
+        except Exception:
+            loaded = None
+        loaded_abspath = loaded.loaded_abspath if loaded else None
+        if loaded_abspath is not None:
+            for parent in Path(loaded_abspath).resolve().parents:
+                if parent.name == browser_name:
+                    logger.info("$ %s", format_command(["rm", "-rf", str(parent)]))
+                    shutil.rmtree(parent, ignore_errors=True)
+                    break
         return True