rea-agents 3.0.0 → 3.2.0

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -0,0 +1,274 @@
+import { realpath } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { _electron as electron } from "playwright-core";
+import { electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
+import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { isPathContained } from "../domain/permissionPolicy.js";
+import { err, ok } from "../domain/result.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, observeOwnedProcessLineage, selectCapturedProcessGroupIds, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
+import { runElectronActions, readApplicationState, runWithExecutionLimits, } from "./PlaywrightElectronActiveActions.js";
+const OPERATION = "capture_electron_scenario";
+const STARTUP_TIMEOUT_MS = 60_000;
+/** Public identity for provider-owned Electron runtime experiments. */
+export const PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY = Object.freeze({
+    id: "rea-playwright-electron-active",
+    name: "REA Playwright active Electron observation provider",
+    version: "1",
+});
+const hookPath = fileURLToPath(new URL("../../scripts/electron-active-hook.cjs", import.meta.url));
+const observableEventFamilies = [
+    "app-lifecycle",
+    "window-lifecycle",
+    "web-contents-lifecycle",
+    "navigation",
+    "shell-attempt",
+    "process-lifecycle",
+    "permission",
+    "popup-attempt",
+    "download",
+    "protocol",
+    "preload",
+    "preload-configuration",
+    "renderer-ipc",
+    "native-addon",
+    "updater",
+    "error",
+    "ipc",
+];
+const ipcEventKinds = new Set([
+    "main-handler-invocation",
+    "main-event-invocation",
+    "utility-process-fork",
+    "utility-process-message",
+    "ipc-main-to-renderer",
+    "ipc-utility-to-main",
+    "ipc-renderer-send",
+    "ipc-renderer-invoke",
+    "ipc-renderer-post-message",
+]);
+const createCoverage = (hookSnapshot) => {
+    const observedEventFamilies = [
+        ...new Set(hookSnapshot.events.map(({ kind, process_type }) => {
+            if (kind === "preload" && process_type === "main")
+                return "preload-configuration";
+            if (kind.startsWith("ipc-renderer") && process_type !== "renderer")
+                return "ipc";
+            return ipcEventKinds.has(kind) ? "ipc" : kind;
+        })),
+    ].sort();
+    const unavailableEventFamilies = new Set(observableEventFamilies.filter((family) => !observedEventFamilies.includes(family)));
+    const observedRoles = [
+        ...new Set(hookSnapshot.events.flatMap(({ process_type, kind }) => [
+            ...(process_type === null ? [] : [process_type]),
+            ...(kind === "window-lifecycle" ? ["window"] : []),
+            ...(kind === "web-contents-lifecycle" || kind === "navigation"
+                ? ["web_contents"]
+                : []),
+            ...(kind === "preload" && process_type === "preload"
+                ? ["preload"]
+                : []),
+            ...(kind.startsWith("ipc-renderer") && process_type === "renderer"
+                ? ["renderer"]
+                : []),
+        ])),
+    ].sort();
+    const rendererContextObserved = hookSnapshot.events.some(({ process_type }) => process_type === "renderer" || process_type === "preload");
+    if (!rendererContextObserved) {
+        unavailableEventFamilies.add("preload");
+        unavailableEventFamilies.add("renderer-ipc");
+    }
+    return {
+        status: hookSnapshot.hook_error ? "hook_conflict" : "partial_attach",
+        observed_event_families: observedEventFamilies,
+        unavailable_event_families: [...unavailableEventFamilies].sort(),
+        observed_roles: observedRoles,
+        pre_capture_activity: "unavailable",
+    };
+};
+/** Launch an owned Electron application through the official Playwright API. */
+export class PlaywrightElectronActiveProvider {
+    identity() {
+        return PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY;
+    }
+    async capture(input, options = {}) {
+        let application;
+        let ownership;
+        let lineage;
+        let outcome;
+        const runId = randomUUID();
+        try {
+            if (options.signal?.aborted === true)
+                throw new BrowserObservationError(OPERATION, "cancelled");
+            const startupDeadline = Date.now() + STARTUP_TIMEOUT_MS;
+            const paths = await canonicalPaths(input);
+            application = await electron.launch({
+                executablePath: paths.executable,
+                cwd: paths.root,
+                env: safeElectronEnvironment(runId),
+                args: ["-r", hookPath, paths.application, ...input.args],
+                timeout: Math.max(1, startupDeadline - Date.now()),
+            });
+            const leaderPid = application.process().pid;
+            if (typeof leaderPid !== "number" ||
+                !Number.isSafeInteger(leaderPid) ||
+                leaderPid <= 0)
+                throw new BrowserObservationError(OPERATION, "process_ownership_unavailable");
+            ownership = {
+                runId,
+                leaderPid,
+                processGroupId: leaderPid,
+                expectedParentPid: process.pid,
+                expectedCommand: paths.executable,
+                sweepTokenOwnedProcesses: true,
+            };
+            const actions = await runElectronActions(application, input, options);
+            const state = await runWithExecutionLimits(readApplicationState(application), options.signal);
+            outcome = ok(createResult(paths, input, actions, state));
+        }
+        catch (cause) {
+            outcome = err(providerError(cause));
+        }
+        if (application !== undefined) {
+            if (ownership !== undefined)
+                lineage = await observeOwnedProcessLineage(ownership);
+            let closeError;
+            try {
+                await runWithExecutionLimits(application.close(), undefined, Date.now() + 5_000);
+            }
+            catch (cause) {
+                closeError = cause;
+            }
+            const cleanup = ownership === undefined
+                ? {
+                    cleaned: false,
+                    reason: "owned Electron process identity was unavailable",
+                }
+                : await cleanupElectronProcesses(ownership, lineage);
+            if (!cleanup.cleaned)
+                return err(providerError(new BrowserObservationError(OPERATION, "cleanup_failed", {
+                    cause: new Error(cleanup.reason),
+                })));
+            if (closeError !== undefined)
+                return err(providerError(closeError));
+        }
+        return outcome;
+    }
+}
+const cleanupElectronProcesses = async (ownership, lineage) => {
+    if (process.platform === "win32") {
+        const root = await cleanupWindowsProcessTree(ownership.leaderPid);
+        if (!root.cleaned)
+            return root;
+        if (lineage?.status !== "verified")
+            return {
+                cleaned: false,
+                reason: "owned Electron lineage was unavailable; helper cleanup was not proven",
+            };
+        for (const descendant of lineage.lineage.descendants) {
+            const result = await cleanupWindowsProcessTree(descendant.pid);
+            if (!result.cleaned)
+                return result;
+        }
+        return root;
+    }
+    if (lineage?.status !== "verified") {
+        const root = await cleanupOwnedProcessGroup(ownership);
+        return root.cleaned
+            ? {
+                cleaned: false,
+                reason: "owned Electron lineage was unavailable; helper cleanup was not proven",
+            }
+            : root;
+    }
+    const groupIds = selectCapturedProcessGroupIds(ownership.leaderPid, lineage.lineage.descendants.map(({ pid, processGroupId }) => ({
+        pid,
+        process_group_id: processGroupId,
+    })));
+    let signaled = false;
+    for (const processGroupId of groupIds) {
+        const cleanupOwnership = processGroupId === ownership.processGroupId
+            ? { ...ownership, leaderPid: processGroupId, processGroupId }
+            : {
+                runId: ownership.runId,
+                leaderPid: processGroupId,
+                processGroupId,
+            };
+        const result = await cleanupOwnedProcessGroup(cleanupOwnership);
+        if (!result.cleaned)
+            return result;
+        signaled ||= result.signaled;
+    }
+    const remaining = await verifyNoTokenOwnedProcesses(ownership.runId);
+    if (!remaining.cleaned)
+        return remaining;
+    return { cleaned: true, signaled };
+};
+const createResult = (paths, input, actions, state) => {
+    const { hookSnapshot } = state;
+    const ipcEvents = hookSnapshot.events.filter(({ kind }) => ipcEventKinds.has(kind));
+    return electronActiveObservationResultSchema.parse({
+        application: {
+            executable_path: paths.executable,
+            application_path: paths.application,
+            electron_version: state.electronVersion,
+            process_ownership: "provider-owned",
+            cleanup: "terminated-owned-process",
+        },
+        actions,
+        windows: state.windows,
+        processes: {
+            items: state.metrics,
+        },
+        ipc: {
+            events: ipcEvents,
+            observed: hookSnapshot.observed_ipc,
+        },
+        timeline: {
+            events: hookSnapshot.events,
+            observed: hookSnapshot.observed,
+        },
+        coverage: createCoverage(hookSnapshot),
+        limitations: [
+            "IPC payloads are represented by value shapes; payload values are never retained.",
+            "IPC direction and sender/receiver identifiers are observed only where Electron exposes them at the hooked boundary.",
+            "The runtime timeline records lifecycle, navigation, shell, permission, popup, download, protocol, preload, native-addon, process, and IPC events; activity before hook installation is unavailable.",
+            "The preload and renderer process contexts are not instrumented by the main-process -r hook; preload configuration and contextBridge API-shape events are main-boundary observations, not proof of renderer-side execution.",
+            "Process metrics are an Electron API snapshot and do not prove hostile-local-user isolation.",
+            "External shell opens, external navigation, permission grants, downloads, popup windows, updater relaunches, and OS integration are blocked and recorded by the active hook; other application filesystem and network behavior is not sandboxed by this provider.",
+            ...(hookSnapshot.hook_error
+                ? ["The active IPC hook could not be installed."]
+                : []),
+        ],
+    });
+};
+const canonicalPaths = async (input) => {
+    const [executable, application, root] = await Promise.all([
+        realpath(input.executable_path),
+        realpath(input.application_path),
+        realpath(input.application_root),
+    ]);
+    if (!isPathContained(root, application))
+        throw new BrowserObservationError(OPERATION, "target_not_allowed");
+    return { executable, application, root };
+};
+const safeElectronEnvironment = (runId) => Object.fromEntries([
+    ...[
+        "HOME",
+        "LANG",
+        "PATH",
+        "TMP",
+        "TMPDIR",
+        "USER",
+        "DISPLAY",
+        "WAYLAND_DISPLAY",
+    ]
+        .map((name) => [name, process.env[name]])
+        .filter((entry) => entry[1] !== undefined),
+    ["REA_PROCESS_RUN_ID", runId],
+]);
+const providerError = (cause) => cause instanceof AnalysisError
+    ? cause
+    : new ProviderAdapterError(PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id, OPERATION, {
+        cause,
+    });

package/dist/browser/PlaywrightExecutionBoundary.js

@@ -1,13 +1,25 @@
 import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/errors.js";
 const OPERATION = "capture_browser_scenario";
-export const withPlaywrightExecutionBoundary = (work, maximumTimeoutMs, signal) => {
-    if (maximumTimeoutMs <= 0)
-        return Promise.reject(new AnalysisTimeoutError(OPERATION, maximumTimeoutMs));
+export const withPlaywrightExecutionBoundary = (work, timeoutMs, signal) => {
+    if (timeoutMs !== undefined && timeoutMs <= 0)
+        return Promise.reject(new AnalysisTimeoutError(OPERATION, timeoutMs));
     if (signal?.aborted === true)
         return Promise.reject(new AnalysisCancelledError(OPERATION));
     return new Promise((resolve, reject) => {
         let settled = false;
         let timer;
+        const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+        const scheduleTimeout = () => {
+            if (deadline === undefined)
+                return;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                fail(new AnalysisTimeoutError(OPERATION, timeoutMs ?? 0));
+                return;
+            }
+            timer = setTimeout(scheduleTimeout, Math.min(remaining, 2_147_483_647));
+            timer.unref();
+        };
         const cleanup = () => {
             if (timer !== undefined)
                 clearTimeout(timer);
@@ -30,8 +42,7 @@ export const withPlaywrightExecutionBoundary = (work, maximumTimeoutMs, signal)
         const onAbort = () => {
             fail(new AnalysisCancelledError(OPERATION));
         };
-        timer = setTimeout(() => fail(new AnalysisTimeoutError(OPERATION, maximumTimeoutMs)), maximumTimeoutMs);
-        timer.unref();
+        scheduleTimeout();
         signal?.addEventListener("abort", onAbort, { once: true });
         if (signal?.aborted === true) {
             onAbort();

package/dist/browser/PlaywrightScenarioActions.js

@@ -14,15 +14,13 @@ const resolveLocator = (page, locator) => {
 const resolveValue = (value, secrets) => secrets.value(value);
 /** Execute one admitted declarative action with no caller-supplied code. */
 export const performPlaywrightScenarioAction = async (input) => {
-    const { page, action, secrets, defaultTimeoutMs, maximumTimeoutMs } = input;
+    const { page, action, secrets } = input;
     const timeout = "timeout_ms" in action ? action.timeout_ms : undefined;
-    const options = {
-        timeout: Math.min(timeout ?? defaultTimeoutMs, maximumTimeoutMs),
-    };
+    const options = timeout === undefined ? {} : { timeout };
     switch (action.action) {
         case "goto":
             await page.goto(secrets.url(action.destination), {
-                timeout: options.timeout,
+                ...options,
                 waitUntil: action.wait_until,
             });
             return;
@@ -55,8 +53,6 @@ export const performPlaywrightScenarioAction = async (input) => {
             });
             return;
         case "wait_for_timeout":
-            if (action.duration_ms > maximumTimeoutMs)
-                throw new Error("Scenario duration limit reached");
             await page.waitForTimeout(action.duration_ms);
     }
 };

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -2,57 +2,21 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
-const TEXT_ARTIFACT_MAX_BYTES = 1_048_576;
 const historyValueSchema = z.strictObject({
     length: z.number().int().min(0),
-    navigation_entries: z
-        .array(z.strictObject({
+    navigation_entries: z.array(z.strictObject({
         type: z.string(),
         name: z.string(),
-    }))
-        .max(10_000),
+    })),
 });
 const storageValueSchema = z.strictObject({
-    local_storage: z.array(z.tuple([z.string(), z.string()])).max(10_000),
-    session_storage: z.array(z.tuple([z.string(), z.string()])).max(10_000),
+    local_storage: z.array(z.tuple([z.string(), z.string()])),
+    session_storage: z.array(z.tuple([z.string(), z.string()])),
 });
-/** Shared retained-count budget for one scenario's screenshot artifacts. */
-export class BrowserScenarioCaptureBudget {
-    maximumScreenshots;
-    maximumMetadataBytes;
-    screenshotCount = 0;
-    metadataBytes = 0;
-    constructor(maximumScreenshots, maximumMetadataBytes) {
-        this.maximumScreenshots = maximumScreenshots;
-        this.maximumMetadataBytes = maximumMetadataBytes;
-    }
-    claimScreenshot() {
-        if (this.screenshotCount >= this.maximumScreenshots)
-            return false;
-        this.screenshotCount += 1;
-        return true;
-    }
-    claimMetadata(bytes) {
-        if (this.metadataBytes + bytes > this.maximumMetadataBytes)
-            return false;
-        this.metadataBytes += bytes;
-        return true;
-    }
-}
 const notRequested = () => ({ state: "not_requested" });
 const missing = (reason) => ({ state: "missing", reason });
-const truncated = (observed, retained, reason) => ({
-    state: "truncated",
-    observed,
-    retained,
-    reason,
-});
-const textArtifact = (text, maximumBytes, budget) => {
+const textArtifact = (text) => {
     const bytes = Buffer.from(text);
-    if (bytes.byteLength > maximumBytes)
-        return truncated(bytes.byteLength, 0, `artifact exceeds ${maximumBytes} bytes`);
-    if (!budget.claimMetadata(bytes.byteLength))
-        return truncated(bytes.byteLength, 0, "scenario metadata byte limit reached");
     return {
         state: "captured",
         value: {
@@ -62,15 +26,7 @@ const textArtifact = (text, maximumBytes, budget) => {
         },
     };
 };
-const metadataArtifact = (value, budget) => {
-    const bytes = Buffer.byteLength(JSON.stringify(value));
-    return budget.claimMetadata(bytes)
-        ? { state: "captured", value }
-        : truncated(bytes, 0, "scenario metadata byte limit reached");
-};
-const captureScreenshot = async (page, scenario, budget) => {
-    if (!budget.claimScreenshot())
-        return truncated(1, 0, "scenario screenshot count limit reached");
+const captureScreenshot = async (page) => {
     try {
         const bytes = await page.screenshot({
             type: "png",
@@ -78,13 +34,10 @@ const captureScreenshot = async (page, scenario, budget) => {
             animations: "disabled",
             caret: "hide",
         });
-        if (bytes.byteLength > scenario.limits.max_screenshot_bytes)
-            return truncated(bytes.byteLength, 0, "screenshot byte limit reached");
         const sha256 = createHash("sha256").update(bytes).digest("hex");
         return {
             state: "captured",
             value: {
-                uri: `rea://web-screenshot/sha256/${sha256}`,
                 sha256,
                 bytes: bytes.byteLength,
                 media_type: "image/png",
@@ -97,25 +50,19 @@ const captureScreenshot = async (page, scenario, budget) => {
     }
 };
 const captureDom = async (input) => {
-    const { page, secrets, maximumBytes, maximumNodes, budget } = input;
+    const { page, secrets } = input;
     try {
-        const nodes = await page.locator("*").count();
-        if (nodes > maximumNodes)
-            return truncated(nodes, 0, "DOM node limit reached");
-        return textArtifact(secrets.redact(await page.content()), Math.min(maximumBytes, TEXT_ARTIFACT_MAX_BYTES), budget);
+        return textArtifact(secrets.redact(await page.content()));
     }
     catch {
         return missing("DOM capture failed");
     }
 };
 const captureAccessibility = async (input) => {
-    const { page, secrets, maximumBytes, maximumNodes, budget } = input;
+    const { page, secrets } = input;
     try {
         const text = await page.locator("html").ariaSnapshot();
-        const nodes = text.split("\n").filter((line) => line.trim() !== "").length;
-        if (nodes > maximumNodes)
-            return truncated(nodes, 0, "accessibility node limit reached");
-        return textArtifact(secrets.redact(text), Math.min(maximumBytes, TEXT_ARTIFACT_MAX_BYTES), budget);
+        return textArtifact(secrets.redact(text));
     }
     catch {
         return missing("accessibility capture failed");
@@ -132,7 +79,7 @@ const navigationType = (value) => {
             return "unknown";
     }
 };
-const captureHistory = async (page, budget) => {
+const captureHistory = async (page) => {
     try {
         const raw = historyValueSchema.parse(await page.evaluate(`(() => ({
         length: window.history.length,
@@ -143,8 +90,6 @@ const captureHistory = async (page, budget) => {
           })
         )
       }))()`));
-        if (raw.navigation_entries.length > 256)
-            return truncated(raw.navigation_entries.length, 0, "navigation history entry limit reached");
         const value = {
             length: raw.length,
             current_url: sanitizeBrowserUrl(page.url()),
@@ -153,25 +98,20 @@ const captureHistory = async (page, budget) => {
                 name: sanitizeBrowserUrl(name),
             })),
         };
-        return metadataArtifact(value, budget);
+        return { state: "captured", value };
     }
     catch {
         return missing("history capture failed");
     }
 };
 const captureStorage = async (input) => {
-    const { context, page, scenario, secrets, budget } = input;
+    const { context, page, scenario, secrets } = input;
     try {
         const cookies = await context.cookies(scenario.allowed_origins);
         const pageStorage = storageValueSchema.parse(await page.evaluate(`(() => ({
         local_storage: Object.entries(window.localStorage),
         session_storage: Object.entries(window.sessionStorage)
       }))()`));
-        const observed = cookies.length +
-            pageStorage.local_storage.length +
-            pageStorage.session_storage.length;
-        if (observed > scenario.limits.max_storage_entries)
-            return truncated(observed, 0, "storage entry limit reached");
         const value = {
             cookies: cookies.map((cookie) => ({
                 name: cookie.name,
@@ -191,7 +131,7 @@ const captureStorage = async (input) => {
                 ...secrets.fingerprint(value),
             })),
         };
-        return metadataArtifact(value, budget);
+        return { state: "captured", value };
     }
     catch {
         return missing("storage capture failed");
@@ -207,7 +147,7 @@ const isAllowedPage = (page, allowedOrigins) => {
 };
 /** Capture selected step artifacts without retaining data after scope loss. */
 export const capturePlaywrightStepArtifacts = async (input) => {
-    const { context, page, scenario, secrets, requested, budget } = input;
+    const { context, page, scenario, secrets, requested } = input;
     const allowed = isAllowedPage(page, new Set(scenario.allowed_origins));
     const denied = () => missing("current page is outside approved origins");
     const state = (kind, capture) => !requested.has(kind)
@@ -216,23 +156,14 @@ export const capturePlaywrightStepArtifacts = async (input) => {
             ? capture()
             : Promise.resolve(denied());
     return browserStepArtifactsSchema.parse({
-        screenshot: await state("screenshot", () => captureScreenshot(page, scenario, budget)),
-        dom: await state("dom", () => captureDom({
-            page,
-            secrets,
-            maximumBytes: scenario.limits.max_total_metadata_bytes,
-            maximumNodes: scenario.limits.max_dom_nodes,
-            budget,
-        })),
-        accessibility: await state("accessibility", () => captureAccessibility({
-            page,
-            secrets,
-            maximumBytes: scenario.limits.max_total_metadata_bytes,
-            maximumNodes: scenario.limits.max_accessibility_nodes,
-            budget,
+        screenshot: await state("screenshot", () => captureScreenshot(page)),
+        dom: await state("dom", () => captureDom({ page, secrets })),
+        accessibility: await state("accessibility", () => captureAccessibility({ page, secrets })),
+        url: await state("url", async () => ({
+            state: "captured",
+            value: sanitizeBrowserUrl(page.url()),
         })),
-        url: await state("url", async () => metadataArtifact(sanitizeBrowserUrl(page.url()), budget)),
-        history: await state("history", () => captureHistory(page, budget)),
-        storage: await state("storage", () => captureStorage({ context, page, scenario, secrets, budget })),
+        history: await state("history", () => captureHistory(page)),
+        storage: await state("storage", () => captureStorage({ context, page, scenario, secrets })),
     });
 };

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -79,19 +79,17 @@ const configureAttachedEnvironment = async (context, page, scenario) => {
         await session.detach();
     }
 };
-export const openPlaywrightScenarioBrowser = async (scenario, environment, maximumTimeoutMs) => {
+export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
     if (scenario.browser.mode === "connect") {
-        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, {
-            timeout: Math.min(scenario.limits.navigation_timeout_ms, maximumTimeoutMs),
-        });
+        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
         try {
             const target = await findConnectedPage(browser, scenario.browser.target_id, new Set(scenario.allowed_origins));
             await configureAttachedEnvironment(target.context, target.page, scenario);
             return { ...target, browser, profilePath: undefined };
         }
-        catch (error) {
+        catch (cause) {
             await browser.close();
-            throw error;
+            throw cause;
         }
     }
     const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
@@ -115,7 +113,7 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, maxim
             handleSIGHUP: false,
             handleSIGINT: false,
             handleSIGTERM: false,
-            timeout: maximumTimeoutMs,
+            timeout: 0,
         });
         const browser = context.browser();
         if (browser === null) {
@@ -125,9 +123,9 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, maxim
         const page = context.pages()[0] ?? (await context.newPage());
         return { context, page, browser, profilePath };
     }
-    catch (error) {
+    catch (cause) {
         await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
-        throw error;
+        throw cause;
     }
 };
 export const closePlaywrightScenarioBrowser = async ({ context, browser, profilePath, }) => {