rea-agents 6.3.0 → 6.4.0

package/dist/browser/PlaywrightScenarioSession.js

@@ -5,16 +5,21 @@ import { failBrowserScenarioOperation, openPlaywrightScenarioBrowser, } from "./
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
 import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js";
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
+import { PlaywrightScenarioStorage } from "./PlaywrightScenarioStorage.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 import { browserScenarioCaptureData, browserScenarioOperationFailure, } from "./BrowserScenarioPartialObservation.js";
 const OPERATION = "capture_browser_scenario";
-const storageSeeds = (blocks, secrets) => {
-    const seeds = {};
-    for (const { origin, entries } of blocks)
-        (seeds[origin] ??= []).push(...entries.map(({ name, value }) => [name, secrets.value(value)]));
-    return seeds;
+const throwIfScenarioCancelled = (signal) => {
+    if (signal?.aborted === true)
+        throw new BrowserObservationError(OPERATION, "cancelled");
 };
-const installStorageSeeds = async (context, page, scenario, secrets) => {
+const throwCleanupFailures = (failures) => {
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1)
+        throw new AggregateError(failures, "Browser scenario cleanup failed");
+};
+const installCookies = async (context, scenario, secrets) => {
     await context.addCookies(scenario.storage.cookies.map((cookie) => ({
         name: cookie.name,
         value: secrets.value(cookie.value),
@@ -23,19 +28,6 @@ const installStorageSeeds = async (context, page, scenario, secrets) => {
         secure: cookie.secure,
         sameSite: cookie.same_site,
     })));
-    const storage = {
-        local: storageSeeds(scenario.storage.local_storage, secrets),
-        session: storageSeeds(scenario.storage.session_storage, secrets),
-    };
-    const payload = JSON.stringify(storage).replaceAll("<", "\\u003c");
-    await page.addInitScript(`(() => {
-    const seeds = ${payload};
-    const local = seeds.local[window.location.origin] ?? [];
-    const session = seeds.session[window.location.origin] ?? [];
-    for (const [name, value] of local) window.localStorage.setItem(name, value);
-    for (const [name, value] of session)
-      window.sessionStorage.setItem(name, value);
-  })()`);
 };
 const blockAttachedServiceWorkers = async (page) => {
     const controller = await page.evaluate("Boolean(navigator.serviceWorker?.controller)");
@@ -58,7 +50,7 @@ const initializePage = async (context, page, scenario, secrets) => {
     context.setDefaultNavigationTimeout(0);
     if (scenario.browser.mode === "connect")
         await blockAttachedServiceWorkers(page);
-    await installStorageSeeds(context, page, scenario, secrets);
+    await installCookies(context, scenario, secrets);
 };
 export class PlaywrightScenarioSession {
     opened;
@@ -69,6 +61,9 @@ export class PlaywrightScenarioSession {
     initialUrl;
     secrets;
     eventCapture;
+    storage;
+    signal;
+    #storageReleased = false;
     constructor(opened, options) {
         this.opened = opened;
         this.mode = options.mode;
@@ -76,72 +71,55 @@ export class PlaywrightScenarioSession {
             options.mode === "launch" ? "provider-owned" : "external";
         this.secrets = options.secrets;
         this.eventCapture = options.eventCapture;
+        this.storage = options.storage;
+        this.signal = options.signal;
         this.version = opened.browser.version();
         this.initialUrl = opened.page.url();
     }
     static async open(scenario, environment, options) {
-        if (options.signal?.aborted === true)
-            throw new BrowserObservationError(OPERATION, "cancelled");
+        throwIfScenarioCancelled(options.signal);
         const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
         const startedAt = Date.now();
         const opening = openPlaywrightScenarioBrowser(scenario, environment, {
             signal: options.signal,
+            ...(options.retainCleanup === undefined
+                ? {}
+                : { retainCleanup: options.retainCleanup }),
         });
         let opened;
-        let events;
         try {
             opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
         }
         catch (cause) {
-            void opening
-                .then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal))
-                .catch((cause) => {
-                // best-effort cleanup: late-open cleanup must not mask the boundary failure.
-                void cause;
+            const lateCleanup = () => opening.then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal), () => undefined);
+            options.retainCleanup?.(() => withPlaywrightExecutionBoundary(lateCleanup, 1_000));
+            void lateCleanup().catch((cleanupCause) => {
+                // best-effort cleanup: retainCleanup keeps the retry capability.
+                void cleanupCause;
             });
             throw cause;
         }
-        let session;
-        try {
-            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
-            events = new PlaywrightScenarioEvents({
-                page: opened.page,
-                context: opened.context,
-                ownsContext: scenario.browser.mode === "launch",
-                enabled: new Set(scenario.capture.events),
-                secrets,
-                network: scenario.capture.network,
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-            });
-            session = new PlaywrightScenarioSession(opened, {
-                mode: scenario.browser.mode,
-                secrets,
-                eventCapture: events,
-            });
-        }
-        catch (cause) {
-            return failBrowserScenarioOperation(() => opened.cleanup.close(events === undefined
-                ? undefined
-                : () => events?.finish() ?? Promise.resolve(), options.signal), cause);
-        }
+        const session = await this.initializeSession(opened, scenario, secrets, options);
         try {
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
                 timeout: 0,
             }), undefined, options.signal);
+            await withPlaywrightExecutionBoundary(() => session.storage?.settle() ?? Promise.resolve(), undefined, options.signal);
             return session;
         }
         catch (cause) {
             let cleanup;
             let cleanupFailure;
             try {
-                cleanup = await session.close();
+                cleanup = await session.close(true);
             }
             catch (failure) {
                 cleanup = "incomplete";
                 cleanupFailure = { cause: failure };
+                options.retainCleanup?.(() => session.close());
             }
             throw browserScenarioOperationFailure(cause, {
                 kind: "browser-scenario-observation",
@@ -158,6 +136,76 @@ export class PlaywrightScenarioSession {
             }, cleanupFailure);
         }
     }
+    static async initializeSession(opened, scenario, secrets, options) {
+        let events;
+        let storage;
+        try {
+            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
+            storage = await PlaywrightScenarioStorage.create(opened, scenario, secrets, {
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.retainCleanup === undefined
+                    ? {}
+                    : { retainCleanup: options.retainCleanup }),
+            });
+            await storage?.initialize(opened.page, opened.context);
+            throwIfScenarioCancelled(options.signal);
+            events = new PlaywrightScenarioEvents({
+                page: opened.page,
+                context: opened.context,
+                ownsContext: scenario.browser.mode === "launch",
+                enabled: new Set(scenario.capture.events),
+                secrets,
+                network: scenario.capture.network,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            });
+            return new PlaywrightScenarioSession(opened, {
+                mode: scenario.browser.mode,
+                secrets,
+                eventCapture: events,
+                storage,
+                signal: options.signal,
+            });
+        }
+        catch (cause) {
+            let storageReleased = false;
+            const cleanup = async () => {
+                let storageFailure;
+                let browserFailure;
+                if (!storageReleased) {
+                    try {
+                        await storage?.close(options.signal?.aborted === true);
+                    }
+                    catch (failure) {
+                        storageFailure = { cause: failure };
+                    }
+                }
+                try {
+                    await opened.cleanup.close(events === undefined
+                        ? undefined
+                        : () => events?.finish() ?? Promise.resolve(), options.signal);
+                }
+                catch (failure) {
+                    browserFailure = { cause: failure };
+                }
+                if (opened.cleanup.browserClosed)
+                    storageReleased = true;
+                throwCleanupFailures([
+                    ...(storageReleased || storageFailure === undefined
+                        ? []
+                        : [storageFailure.cause]),
+                    ...(browserFailure === undefined ? [] : [browserFailure.cause]),
+                ]);
+            };
+            try {
+                return await failBrowserScenarioOperation(cleanup, cause);
+            }
+            catch (failure) {
+                if (failure !== cause)
+                    options.retainCleanup?.(cleanup);
+                throw failure;
+            }
+        }
+    }
     currentUrl() {
         return this.opened.page.url();
     }
@@ -186,8 +234,10 @@ export class PlaywrightScenarioSession {
             action,
             secrets: this.secrets,
         }), "timeout_ms" in action ? action.timeout_ms : undefined, signal);
+        await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
     }
     async capture(requested, signal) {
+        await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
         return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
             context: this.opened.context,
             page: this.opened.page,
@@ -195,8 +245,31 @@ export class PlaywrightScenarioSession {
             requested,
         }), undefined, signal);
     }
-    async close() {
-        await this.opened.cleanup.close(() => this.eventCapture.finish());
+    async close(stopLoading = this.signal?.aborted === true) {
+        let storageFailure;
+        let browserFailure;
+        if (!this.#storageReleased) {
+            try {
+                await this.storage?.close(stopLoading);
+            }
+            catch (failure) {
+                storageFailure = { cause: failure };
+            }
+        }
+        try {
+            await this.opened.cleanup.close(() => this.eventCapture.finish());
+        }
+        catch (failure) {
+            browserFailure = { cause: failure };
+        }
+        if (this.opened.cleanup.browserClosed)
+            this.#storageReleased = true;
+        throwCleanupFailures([
+            ...(this.#storageReleased || storageFailure === undefined
+                ? []
+                : [storageFailure.cause]),
+            ...(browserFailure === undefined ? [] : [browserFailure.cause]),
+        ]);
         return this.mode === "launch"
             ? "terminated-owned-process"
             : "disconnected-external";