pi-lean-dimension 0.1.0 → 0.2.0

package/node_modules/pi-lean-portal/contributed/invisible-py/bridge.py

@@ -0,0 +1,434 @@
+#!/usr/bin/env python3
+"""
+Invisible-Py Bridge — Python-side stealth backend using invisible_playwright.
+
+**This is a user-installed backend — it does NOT ship in the npm tarball.**
+To install, copy this file and its ``.venv/`` to::
+
+    ~/.pi/agent/pi-lean-portal/user-backends/invisible-py/bridge.py
+
+Then create a virtual environment, install dependencies, fetch the binary,
+and add the plugin entry to your ``settings.json``.
+
+Lifecycle pattern: engine owns its own Playwright instance
+-----------------------------------------------------------
+Unlike some stealth backends (notably shipped Camoufox) which accept an
+external Playwright instance and only override ``_launch_browser``, this
+bridge uses **lifecycle pattern #2**: the engine (``InvisiblePlaywright``)
+starts its own Playwright instance inside ``__enter__()`` and owns it.
+The base class normally calls ``_ensure_playwright()`` → ``sync_playwright().start()``
+→ ``_launch_browser()``.  To avoid two Playwright instances, this bridge
+overrides both ``_ensure_playwright`` and ``_maybe_stop_playwright`` to
+delegate to the ``InvisiblePlaywright`` context manager.
+
+For the same reason, ``_launch_browser()`` is NOT overridden — the base's
+``_launch_browser`` is never called because ``_ensure_playwright`` completely
+replaces the launch path.
+
+This pattern is the **unique probe** for the architecture's ability to
+handle backends that manage their own Playwright lifecycle.
+
+Quirks rationale
+-----------------
+``_fingerprint_managed_context = True``
+    The base's ``create_browser_context()`` unconditionally sets
+    ``viewport: {1280, 720}`` and ``user_agent: effective_user_agent``.
+    The patched Firefox binary generates viewport, user_agent, screen, dpr
+    from the fingerprint with "user wins" semantics.  Without this flag,
+    the base's hard-coded values would override the fingerprint — producing
+    a detectable mismatch.
+
+``_capture_user_agent = False``
+    ``_capture_ua()`` probes the UA via a throwaway ``self._browser.new_page()``,
+    which creates an implicit BrowserContext that is never closed. On the
+    patched Firefox binary, that leftover context reliably deadlocks the
+    Juggler driver when a subsequent BrowserContext's ``new_page()`` is
+    created — the second ``browser.navigate`` for a different task hangs
+    forever inside the Playwright sync greenlet.  UA capture is also
+    pointless here: with ``_fingerprint_managed_context = True``,
+    ``create_browser_context()`` does NOT pass ``user_agent`` to
+    ``new_context`` (the fingerprint package sets it), so
+    ``effective_user_agent`` is never read.
+
+``_skip_networkidle = True``
+    The patched Firefox binary does not fire ``networkidle`` reliably.
+    Waiting for it in ``do_go_back`` / ``_wait_for_page_ready`` either
+    times out (30s) or loiters in the Playwright sync greenlet long enough
+    to risk deadlocking the Juggler driver when a subsequent BrowserContext
+    is created.  This flag makes navigation settle use ``load`` instead of
+    ``networkidle``, matching ``do_navigate``'s load-based settle.
+
+Back navigation (``/web back``)
+--------------------------------
+The patched Firefox binary does not support back/forward navigation:
+``page.go_back()`` times out for every ``wait_until`` value and the URL
+never changes.  This bridge's ``do_go_back`` implements a
+``document.referrer`` workaround: re-navigate to the referrer URL via
+``page.goto``.  This covers the dominant agent pattern (click a link →
+wrong way → go back).  When ``document.referrer`` is empty (direct
+navigations, ``rel=noreferrer`` links), the bridge returns ``success: false``
+with a clear error — it is an honest limitation, not a silent no-op.
+
+Requires
+--------
+* Python >= 3.10
+* ``invisible-playwright`` installed (``pip install invisible-playwright``)
+* Fetched patched Firefox binary (``python -m invisible_playwright fetch``)
+* ``xvfb`` system package on Linux for ``headless=True``
+"""
+
+import json
+import os
+import re
+import sys
+import time
+from typing import Any
+
+from pi_browser_bridge.playwright_base import PlaywrightBridge
+from pi_browser_bridge.bridge import SessionNotFoundError
+
+
+class InvisiblePyBridge(PlaywrightBridge):
+    """Stealth bridge using invisible_playwright (Firefox-based).
+
+    Uses lifecycle pattern #2: overrides ``_ensure_playwright`` and
+    ``_maybe_stop_playwright`` to delegate to an ``InvisiblePlaywright``
+    context manager, which owns its own Playwright instance and patches
+    ``browser.new_context`` for fingerprint coherence.
+    """
+
+    _plugin_name: str = "invisible-py"
+    _fingerprint_managed_context: bool = True
+    # invisible_playwright's patched Firefox binary routes page.evaluate
+    # through eval() in the page's main world (a stealth measure that kills
+    # Juggler's isolated-world debugger signature).  The page's CSP then
+    # applies, so on CSP-strict sites (e.g. Reddit, which forbids
+    # unsafe-eval) every page.evaluate fails with "call to eval() blocked
+    # by CSP".  This is invisible_playwright-specific — Camoufox keeps
+    # Juggler's CSP-free isolated-world + MainWorldContext.executeInGlobal
+    # paths, so camoufox-py read-only evals bypass CSP and need no quirk.
+    # The flag makes do_evaluate(read_only=True) read the EXTRACTOR_SCRIPT
+    # result from a <meta> tag that an add_init_script (isolated world,
+    # CSP-free) stashes at DOMContentLoaded.  See the base quirk docstring.
+    _csp_safe_readonly_via_init_script: bool = True
+    # invisible_playwright's patched Firefox binary also routes write evals
+    # like window.scrollBy through eval() in the page's main world, hitting
+    # CSP on strict sites.  page.mouse.wheel drives scroll via input events
+    # instead — CSP-free.  Same fix as camoufox-py.
+    _scroll_via_wheel: bool = True
+    # The patched Firefox binary doesn't fire `networkidle` reliably; waiting for
+    # it in `do_go_back` / `_wait_for_page_ready` either times out (30s) or
+    # loiters in the Playwright sync greenlet long enough to deadlock the
+    # Juggler driver when a subsequent BrowserContext's `new_page()` is
+    # created.  Match `do_navigate`'s load-based settle instead.
+    _skip_networkidle: bool = True
+    # NOTE: UA capture is intentionally DISABLED.
+    # `_capture_ua()` probes the UA via a throwaway `self._browser.new_page()`,
+    # which creates an implicit BrowserContext that is never closed. On the
+    # patched Firefox binary, that leftover context reliably deadlocks the
+    # Juggler driver when a subsequent (second) BrowserContext's `new_page()`
+    # is created — the second `browser.navigate` for a different task hangs
+    # forever inside the Playwright sync greenlet.
+    # It is also pointless here: with `_fingerprint_managed_context = True`,
+    # `create_browser_context()` does NOT pass `user_agent` to `new_context`
+    # (the fingerprint package sets it), so `effective_user_agent` is never
+    # read. The base's `_user_agent` fallback is similarly unused.
+    _capture_user_agent: bool = False
+    _install_hint: str = (
+        "invisible-playwright browser not installed.\n"
+        "Run the following commands in your invisible-py virtual environment:\n"
+        "  pip install invisible-playwright\n"
+        "  python -m invisible_playwright fetch\n"
+        "On Linux, also install xvfb:\n"
+        "  apt-get install xvfb"
+    )
+
+    #: The ``InvisiblePlaywright`` context manager instance, held for the
+    #: bridge's lifetime.  ``None`` before the first call to
+    #: ``_ensure_playwright()``.
+    _stealth_ctx = None
+
+    def _ensure_playwright(self):  # type: ignore[override]
+        """Override base lifecycle to delegate to InvisiblePlaywright.
+
+        Instead of calling ``sync_playwright().start()`` +
+        ``_launch_browser()``, we instantiate ``InvisiblePlaywright`` from
+        the plugin config and enter the context manager, which returns a
+        patched Playwright Browser.  The Playwright handle is read from
+        ``self._stealth_ctx._pw``.
+
+        Returns:
+            ``(pw, browser)`` — the Playwright instance and Browser.
+        """
+        if self._pw is None:
+            # Lazy import invisible_playwright — gives better error messages
+            # and avoids import cost when this bridge is disabled.
+            try:
+                from invisible_playwright import InvisiblePlaywright  # type: ignore[import-unresolved]
+            except ImportError as exc:
+                raise RuntimeError(self._install_hint) from exc
+
+            # Read launch options from browser.init plugin config
+            launch = self.plugin_config.get("launch", {}) or {}
+
+            # Map camelCase keys from TypeScript settings to snake_case
+            # Python kwargs.  Only forward keys that
+            # invisible_playwright.InvisiblePlaywright accepts.
+            kwargs: dict[str, object] = {
+                # Default to headless=True for server agents (no X display needed).
+                # invisible_playwright's ``headless=True`` uses Xvfb to hide the
+                # window while keeping the real rendering pipeline (coherent
+                # fingerprint).  Users can override via ``headless=False`` for
+                # local headed debugging or ``headless='virtual'`` for the
+                # PyVirtualDisplay-based approach.
+                "headless": launch.get("headless", True),
+            }
+            _KEY_MAP: dict[str, str] = {
+                "seed": "seed",
+                "proxy": "proxy",
+                "humanize": "humanize",
+                "locale": "locale",
+                "timezone": "timezone",
+                "extraPrefs": "extra_prefs",
+                "binaryPath": "binary_path",
+                "prepRecaptcha": "prep_recaptcha",
+                "pin": "pin",
+            }
+            for ts_key, py_key in _KEY_MAP.items():
+                if ts_key in launch:
+                    kwargs[py_key] = launch[ts_key]
+
+            self._stealth_ctx = InvisiblePlaywright(**kwargs)
+            try:
+                # __enter__() returns a Browser (not a BrowserContext when
+                # profile_dir is omitted — which is what we want).
+                self._browser = self._stealth_ctx.__enter__()
+            except Exception as _exc:
+                if re.search(
+                    r"Executable doesn't exist|browserType\.launch",
+                    str(_exc),
+                    re.IGNORECASE,
+                ):
+                    raise RuntimeError(self._install_hint) from _exc
+                raise
+
+            # Read the Playwright handle from the InvisiblePlaywright instance.
+            # InvisiblePlaywright owns sync_playwright(); the Browser it
+            # returns does not expose _pw.
+            self._pw = self._stealth_ctx._pw
+
+        # Probe UA at first launch
+        if self._capture_user_agent:
+            self._capture_ua()
+        return self._pw, self._browser
+
+    def create_browser_context(self, config: dict[str, Any]) -> Any:
+        """Override base context creation to neutralize invisible_playwright's
+        injected ``new_context`` defaults.
+
+        Why the base's ``_skip_default_viewport`` flag is NOT enough:
+        invisible_playwright (lifecycle pattern #2) patches
+        ``browser.new_context`` to merge in ``viewport`` + ``screen`` +
+        ``device_scale_factor`` defaults derived from the spoofed fingerprint
+        — unlike Camoufox, which injects the fingerprint at browser *launch*
+        via ``NewBrowser`` and leaves ``new_context`` vanilla.  The base's
+        ``_skip_default_viewport`` path passes only ``no_viewport=True``, which
+        works for Camoufox (vanilla ``new_context``) but fails here because the
+        patched ``new_context`` injects ``viewport`` under a *different* key, so
+        ``no_viewport`` cannot override it — Playwright still issues
+        ``Browser.setDefaultViewport`` and the patched Firefox binary rejects
+        the ``screenSize`` field it includes.
+
+        Verified empirically against the real patched binary, the only
+        combination that works is to override ALL THREE injected defaults to
+        ``None`` AND pass ``no_viewport=True``:
+          * ``viewport=None`` → Playwright sees ``viewport === null`` → sets
+            ``noDefaultViewport=True`` → the ``setDefaultViewport`` CDP call is
+            skipped entirely (its guard is ``if (!viewport) return``).
+          * ``device_scale_factor=None`` → clears the injected default that
+            otherwise triggers Playwright's "deviceScaleFactor not supported
+            with null viewport" validation.
+          * ``screen=None`` → clears the remaining injected default.
+
+        The fingerprint still manages viewport/screen/dpr *inside* the browser
+        process (the patched binary spoofs screen at the window level); we are
+        only stopping Playwright from re-sending them via the CDP call the
+        binary cannot handle — functionally the same as Camoufox's
+        ``no_viewport=True`` path, just requiring the extra None overrides
+        because of the ``new_context``-time injection.
+        """
+        _pw, browser = self._ensure_playwright()
+
+        context_kwargs: dict[str, Any] = {
+            "no_viewport": True,
+            # Override the three defaults invisible_playwright's patched
+            # new_context injects — each must be None, or no_viewport is
+            # either ignored (viewport) or rejected (device_scale_factor).
+            "viewport": None,
+            "screen": None,
+            "device_scale_factor": None,
+        }
+        storage_state = config.get("storageState")
+        if storage_state is not None:
+            context_kwargs["storage_state"] = storage_state
+
+        context = browser.new_context(**context_kwargs)
+
+        # Start Playwright trace capture if BROWSER_TRACE_DIR is set.
+        _trace_dir = os.environ.get("BROWSER_TRACE_DIR")
+        if _trace_dir:
+            try:
+                context.tracing.start(
+                    screenshots=True,
+                    snapshots=True,
+                    sources=True,
+                )
+                self._log("tracing", taskId=config.get("_task_id", "shared"),
+                          action="start", dir=_trace_dir)
+            except Exception:
+                pass  # Best-effort
+
+        # CSP-safe read-only eval path — register the EXTRACTOR_SCRIPT as an
+        # init script (isolated world, CSP-free) that stashes its result in a
+        # <meta> tag at DOMContentLoaded.  See _csp_safe_readonly_via_init_script.
+        self._register_readonly_extractor_init_script(context)
+
+        return context
+
+    def _maybe_stop_playwright(self) -> None:
+        """Stop the InvisiblePlaywright when no sessions remain.
+
+        Calls ``self._stealth_ctx.__exit__(None, None, None)`` instead of
+        ``self._pw.stop()`` so the context manager properly cleans up its
+        own Playwright instance and the patched Firefox binary.
+        """
+        if not self.sessions and self._stealth_ctx is not None:
+            try:
+                if self._browser:
+                    self._browser.close()
+            except Exception:
+                pass
+            try:
+                self._stealth_ctx.__exit__(None, None, None)
+            except Exception:
+                pass
+            self._pw = None
+            self._browser = None
+            self._stealth_ctx = None
+
+    def do_go_back(self, task_id: str) -> dict[str, Any]:
+        """Navigate back — workaround for the patched Firefox binary's broken
+        history navigation.
+
+        The patched Firefox binary does not support back/forward navigation:
+        ``page.go_back()`` times out for every ``wait_until`` value
+        (``networkidle`` / ``load`` / ``domcontentloaded`` / ``commit`` /
+        default) and the URL never changes.  Standard Playwright Firefox
+        (the ``firefox-py`` backend) works in 0.01s — so this is a
+        patched-binary limitation, not a Playwright or bridge bug.  Root
+        cause is the binary's ``disallowBFCache`` stealth attribute combined
+        with Fission and the about:newtab race.
+
+        Workaround: re-navigate to ``document.referrer`` via ``page.goto``.
+        This covers the dominant agent pattern (click a link → wrong way →
+        go back), where ``document.referrer`` is populated.  It's a re-fetch
+        rather than a true history back, but the patched binary has bfcache
+        disabled anyway, so a true history back would re-render from scratch
+        too — functionally identical.
+
+        Falls through with ``success: false`` when ``document.referrer``
+        is empty (direct navigations, ``rel=noreferrer`` links, POST
+        submissions, multi-step back).  This is an honest limitation — the
+        error message is explicit about what's not supported, so agents can
+        react appropriately.
+        """
+        _t_start = time.time()
+        try:
+            page = self._get_page(task_id)
+        except SessionNotFoundError:
+            raise
+        except Exception as exc:
+            self._log("goBack", taskId=task_id, success=False,
+                      time=round((time.time() - _t_start) * 1000))
+            return {"success": False, "error": f"GoBack failed: {exc}"}
+
+        # Try the referrer workaround first.
+        referrer: str = ""
+        try:
+            referrer = page.evaluate("() => document.referrer") or ""
+        except Exception:
+            referrer = ""
+
+        if not referrer:
+            # No referrer → return an immediate error instead of timing out
+            # via ``super().do_go_back()`` (which calls ``page.go_back()`` —
+            # broken on this patched binary, always times out).
+            self._log("goBack", taskId=task_id, success=False,
+                      reason="no referrer (fallback not supported on this binary)",
+                      time=round((time.time() - _t_start) * 1000))
+            return {
+                "success": False,
+                "error": (
+                    "GoBack not supported for direct/noreferrer navigations "
+                    "on this patched Firefox binary (history navigation is "
+                    "non-functional)"
+                ),
+            }
+
+        try:
+            page.goto(referrer, wait_until="load", timeout=15_000)
+
+            new_url: str = page.url
+            new_title: str = page.title()
+            snap_text, element_count, elements = self._take_snapshot_and_cache(
+                task_id, page
+            )
+            self._log("goBack", taskId=task_id, success=True,
+                      elementCount=element_count, via="referrer",
+                      time=round((time.time() - _t_start) * 1000))
+            return {
+                "success": True,
+                "snapshot": snap_text,
+                "elementCount": element_count,
+                "elements": elements,
+                "dialogEvents": self._get_dialog_events(task_id),
+                "newUrl": new_url,
+                "newTitle": new_title,
+            }
+        except Exception as exc:
+            self._log("goBack", taskId=task_id, success=False, via="referrer",
+                      time=round((time.time() - _t_start) * 1000))
+            return {"success": False, "error": f"GoBack failed: {exc}"}
+
+
+# ═══════════════════════════════════════════════════════════════════════
+#  Entry point
+# ═══════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    # The stealth engine bundles its own Playwright, so we check for the
+    # engine itself rather than the standard playwright package.
+    # Print a JSON-RPC error and exit immediately so the TypeScript
+    # PythonPluginAdapter gets a parseable error.
+    try:
+        import invisible_playwright  # type: ignore[import-unresolved] # noqa: F401
+    except ImportError:
+        print(
+            json.dumps({
+                "jsonrpc": "2.0",
+                "id": None,
+                "error": {
+                    "code": -32000,
+                    "message": (
+                        "invisible-playwright is not installed.\n"
+                        "Run: pip install invisible-playwright && "
+                        "python -m invisible_playwright fetch"
+                    ),
+                },
+            })
+        )
+        sys.stdout.flush()
+        sys.exit(1)
+
+    bridge = InvisiblePyBridge()
+    bridge.run()

package/node_modules/pi-lean-portal/core/fetch-backend.ts

@@ -312,11 +312,6 @@ export function cleanupFetchTempFiles(taskId?: string): void {
 			}
 		}
 		activeFetchFiles.clear();
-		try {
-			rmSync(BROWSER_TEMP_DIR, { recursive: true, force: true });
-		} catch {
-			/* best-effort */
-		}
 	}
 }
 

package/node_modules/pi-lean-portal/core/plugin-api.ts

@@ -21,18 +21,8 @@ import type { AriaCachedNode } from "./shared/accessibility-tree.js";
  * screenshot when unsupported).
  */
 export interface PluginCapabilities {
-	/** Can take full-page screenshots */
 	supportsFullPageScreenshot: boolean;
-	/** Can capture console messages via CDP or equivalent */
-	supportsConsoleCapture: boolean;
-	/** Can evaluate arbitrary JavaScript in the page */
 	supportsJavaScriptEvaluate: boolean;
-	/** Can detect bot/anti-automation signals (Cloudflare, CAPTCHA, etc.) */
-	supportsBotDetection: boolean;
-	/** Can auto-dismiss JS dialogs (alert/confirm/prompt) */
-	supportsDialogAutoDismissal: boolean;
-	/** Can accept an AbortSignal for long-running navigations */
-	supportsAbortSignal: boolean;
 	/** Browser engine (used for display/debugging only) */
 	engine: "chromium" | "firefox" | "webkit" | string;
 }
@@ -40,11 +30,7 @@ export interface PluginCapabilities {
 /** Default capabilities matching a full-featured Chromium backend. */
 export const DEFAULT_CAPABILITIES: PluginCapabilities = {
 	supportsFullPageScreenshot: true,
-	supportsConsoleCapture: true,
 	supportsJavaScriptEvaluate: true,
-	supportsBotDetection: true,
-	supportsDialogAutoDismissal: true,
-	supportsAbortSignal: true,
 	engine: "chromium",
 };
 
@@ -59,7 +45,6 @@ export const DEFAULT_CAPABILITIES: PluginCapabilities = {
 export interface DialogEvent {
 	/** Dialog type as reported by the browser */
 	type: string;
-	/** Dialog message text */
 	message: string;
 	/** How the dialog was handled (always "accepted" for auto-dismiss) */
 	handledAs: "accepted" | "dismissed";
@@ -76,13 +61,11 @@ export interface ResultBase {
 	error?: string;
 }
 
-/** Result from browser-navigate */
 export interface NavigateResult extends ResultBase {
 	url: string;
 	title: string;
 	/** Accessibility-tree text with @e refs */
 	snapshot: string;
-	/** Number of interactive elements found */
 	elementCount: number;
 	/** Plugin-internal signal: page may be blocked by bot detection */
 	botDetected?: boolean;
@@ -90,17 +73,14 @@ export interface NavigateResult extends ResultBase {
 	dialogDetected?: boolean;
 	/** Auto-dismissed JavaScript dialogs (alert/confirm/prompt) since last navigate */
 	dialogEvents?: DialogEvent[];
-	/** The active profile mode for this session. */
 	profileMode?: "none" | "session" | "named";
 	/** Which profile was loaded for this session (if any) */
 	profileName?: string;
 }
 
-/** Result from browser-snapshot */
 export interface SnapshotResult extends ResultBase {
 	/** Accessibility-tree text with @e refs */
 	snapshot: string;
-	/** Number of interactive elements found */
 	elementCount: number;
 	/** Auto-dismissed JavaScript dialogs (alert/confirm/prompt) since last snapshot */
 	dialogEvents?: DialogEvent[];
@@ -114,19 +94,16 @@ export interface InteractionResult extends ResultBase {
 	newTitle?: string;
 	/** Auto-captured snapshot after the interaction */
 	snapshot?: string;
-	/** Number of interactive elements in the auto-snapshot */
 	elementCount?: number;
 	/** Auto-dismissed JavaScript dialogs since the interaction */
 	dialogEvents?: DialogEvent[];
 }
 
-/** Result from plugin.screenshot() */
 export interface ScreenshotResult extends ResultBase {
 	/** JPEG data URI of the screenshot */
 	dataUri: string;
 }
 
-/** Result from getConsoleMessages */
 export interface ConsoleMessagesResult extends ResultBase {
 	messages: Array<{ type: string; text: string }>;
 }
@@ -157,7 +134,6 @@ export interface Cookie {
 	sameSite?: "Strict" | "Lax" | "None";
 }
 
-/** Result from browser-getCookies */
 export interface CookieResult extends ResultBase {
 	cookies: Cookie[];
 }
@@ -169,7 +145,6 @@ export interface ClearCookiesOptions {
 	path?: string;
 }
 
-/** Result from browser-getStorageState */
 export interface StorageStateResult extends ResultBase {
 	cookies: Cookie[];
 	origins: Array<{
@@ -183,7 +158,7 @@ export interface StorageStateResult extends ResultBase {
 /**
  * The contract every interactive browser backend must implement.
  *
- * The 12 required operations (plus getElementCache and cookie/storage
+ * The 18 required operations (plus getElementCache and cookie/storage
  * methods) make up the full contract. Lifecycle hooks are called by
  * the framework, not the agent.
  */
@@ -231,9 +206,6 @@ export interface BrowserPlugin {
 
 	// ── Cookies & storage state ────────────────────────────────
 
-	/**
-	 * Get all browser cookies for the session, optionally filtered by URL.
-	 */
 	getCookies(taskId: string, urls?: string[]): Promise<CookieResult>;
 
 	/**
@@ -282,7 +254,11 @@ export interface BrowserPlugin {
 
 	clearConsole(taskId: string): Promise<void>;
 
-	evaluate(taskId: string, expression: string): Promise<EvaluateResult>;
+	evaluate(
+		taskId: string,
+		expression: string,
+		readOnly?: boolean,
+	): Promise<EvaluateResult>;
 
 	// ── Element cache access ─────────────────────────────────
 
@@ -295,8 +271,5 @@ export interface BrowserPlugin {
 
 	// ── Per-task cleanup ──────────────────────────────────────
 
-	/**
-	 * Clean up resources for a specific task (browser context, page, etc.).
-	 */
 	cleanup(taskId: string): Promise<void>;
 }