rea-agents 2.4.0 → 3.0.0

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -0,0 +1,144 @@
+import { chmod, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { chromium, } from "playwright-core";
+import { BrowserObservationError } from "../domain/errors.js";
+const OPERATION = "capture_browser_scenario";
+const allowedBrowserEnvironment = (environment) => {
+    const allowed = [
+        "DBUS_SESSION_BUS_ADDRESS",
+        "DISPLAY",
+        "HOME",
+        "LANG",
+        "LD_LIBRARY_PATH",
+        "PATH",
+        "SystemRoot",
+        "TEMP",
+        "TMP",
+        "TMPDIR",
+        "WAYLAND_DISPLAY",
+        "XAUTHORITY",
+        "XDG_RUNTIME_DIR",
+    ];
+    return Object.fromEntries(allowed
+        .map((name) => [name, environment[name]])
+        .filter((entry) => entry[1] !== undefined));
+};
+const originAllowed = (value, allowedOrigins) => {
+    try {
+        return allowedOrigins.has(new URL(value).origin);
+    }
+    catch {
+        return false;
+    }
+};
+const findConnectedPage = async (browser, targetId, allowedOrigins) => {
+    for (const context of browser.contexts())
+        for (const page of context.pages()) {
+            const session = await context.newCDPSession(page);
+            try {
+                const { targetInfo } = await session.send("Target.getTargetInfo");
+                if (targetInfo.targetId !== targetId)
+                    continue;
+                if (page.url() !== "about:blank" &&
+                    !originAllowed(page.url(), allowedOrigins))
+                    throw new BrowserObservationError(OPERATION, "target_not_allowed");
+                return { context, page };
+            }
+            finally {
+                await session.detach();
+            }
+        }
+    throw new BrowserObservationError(OPERATION, "target_not_found");
+};
+const configureAttachedEnvironment = async (context, page, scenario) => {
+    await page.setViewportSize({
+        width: scenario.environment.viewport.width,
+        height: scenario.environment.viewport.height,
+    });
+    await page.emulateMedia({
+        colorScheme: scenario.environment.color_scheme,
+        reducedMotion: scenario.environment.reduced_motion,
+    });
+    const session = await context.newCDPSession(page);
+    try {
+        await session.send("Emulation.setDeviceMetricsOverride", {
+            width: scenario.environment.viewport.width,
+            height: scenario.environment.viewport.height,
+            deviceScaleFactor: scenario.environment.viewport.device_scale_factor,
+            mobile: false,
+        });
+        await session.send("Emulation.setLocaleOverride", {
+            locale: scenario.environment.locale,
+        });
+        await session.send("Emulation.setTimezoneOverride", {
+            timezoneId: scenario.environment.timezone,
+        });
+    }
+    finally {
+        await session.detach();
+    }
+};
+export const openPlaywrightScenarioBrowser = async (scenario, environment, maximumTimeoutMs) => {
+    if (scenario.browser.mode === "connect") {
+        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, {
+            timeout: Math.min(scenario.limits.navigation_timeout_ms, maximumTimeoutMs),
+        });
+        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) {
+            await browser.close();
+            throw error;
+        }
+    }
+    const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
+    await chmod(profilePath, 0o700);
+    try {
+        const context = await chromium.launchPersistentContext(profilePath, {
+            executablePath: scenario.browser.executable_path,
+            headless: true,
+            acceptDownloads: false,
+            viewport: {
+                width: scenario.environment.viewport.width,
+                height: scenario.environment.viewport.height,
+            },
+            deviceScaleFactor: scenario.environment.viewport.device_scale_factor,
+            locale: scenario.environment.locale,
+            timezoneId: scenario.environment.timezone,
+            colorScheme: scenario.environment.color_scheme,
+            reducedMotion: scenario.environment.reduced_motion,
+            serviceWorkers: "block",
+            env: allowedBrowserEnvironment(environment),
+            handleSIGHUP: false,
+            handleSIGINT: false,
+            handleSIGTERM: false,
+            timeout: maximumTimeoutMs,
+        });
+        const browser = context.browser();
+        if (browser === null) {
+            await context.close();
+            throw new BrowserObservationError(OPERATION, "protocol_error");
+        }
+        const page = context.pages()[0] ?? (await context.newPage());
+        return { context, page, browser, profilePath };
+    }
+    catch (error) {
+        await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
+        throw error;
+    }
+};
+export const closePlaywrightScenarioBrowser = async ({ context, browser, profilePath, }) => {
+    try {
+        if (profilePath === undefined)
+            await browser.close();
+        else
+            await context.close();
+    }
+    finally {
+        if (profilePath !== undefined)
+            await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
+    }
+};

package/dist/browser/PlaywrightScenarioEvents.js

@@ -0,0 +1,301 @@
+import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
+import { browserScenarioEventSchema, } from "../domain/browserScenarioCapture.js";
+/** Bounded, arrival-ordered Playwright event capture with current-step attribution. */
+export class PlaywrightScenarioEvents {
+    items = [];
+    truncated = new Set();
+    admitted = {
+        frames: new WeakSet(),
+        workers: new WeakSet(),
+        popups: new WeakSet(),
+        websockets: new WeakSet(),
+    };
+    rejected = {
+        frames: new WeakSet(),
+        workers: new WeakSet(),
+        popups: new WeakSet(),
+        websockets: new WeakSet(),
+    };
+    counts = {
+        frames: 0,
+        workers: 0,
+        popups: 0,
+        websockets: 0,
+    };
+    dropped = 0;
+    stepIndex = 0;
+    sequence = 0;
+    enabled;
+    limits;
+    secrets;
+    budget;
+    allowedOrigins;
+    constructor(options) {
+        this.enabled = options.enabled;
+        this.limits = options.limits;
+        this.secrets = options.secrets;
+        this.budget = options.budget;
+        this.allowedOrigins = new Set(options.allowedOrigins);
+        this.observePage(options.page);
+    }
+    setStep(index) {
+        this.stepIndex = index;
+    }
+    nextSequence() {
+        return this.sequence + 1;
+    }
+    lastSequence() {
+        return this.sequence;
+    }
+    result() {
+        return {
+            retained: this.items.length,
+            dropped: this.dropped,
+            items: this.items,
+        };
+    }
+    truncationSections() {
+        return [...this.truncated].sort();
+    }
+    push(event) {
+        this.sequence += 1;
+        if (this.items.length >= this.limits.max_events) {
+            this.dropped += 1;
+            this.truncated.add("events");
+            return;
+        }
+        const parsed = browserScenarioEventSchema.parse({
+            ...event,
+            sequence: this.sequence,
+            step_index: this.stepIndex,
+        });
+        if (!this.budget.claimMetadata(Buffer.byteLength(JSON.stringify(parsed)))) {
+            this.dropped += 1;
+            this.truncated.add("events");
+            return;
+        }
+        this.items.push(parsed);
+    }
+    admit(section, value, maximum) {
+        if (this.admitted[section].has(value))
+            return true;
+        if (this.rejected[section].has(value))
+            return false;
+        if (this.counts[section] >= maximum) {
+            this.rejected[section].add(value);
+            this.sequence += 1;
+            this.dropped += 1;
+            this.truncated.add("events");
+            this.truncated.add(section);
+            return false;
+        }
+        this.admitted[section].add(value);
+        this.counts[section] += 1;
+        return true;
+    }
+    observePage(page) {
+        if (this.enabled.has("console"))
+            page.on("console", (message) => {
+                if (this.pageInScope(page))
+                    this.console(message);
+            });
+        if (this.enabled.has("page-errors"))
+            page.on("pageerror", (error) => {
+                if (this.pageInScope(page))
+                    this.push({
+                        kind: "page-error",
+                        message: this.secrets.redact(error.message).slice(0, 65_536),
+                        stack: error.stack === undefined
+                            ? null
+                            : this.secrets.redact(error.stack).slice(0, 262_144),
+                    });
+            });
+        if (this.enabled.has("network")) {
+            page.on("request", (request) => {
+                if (this.pageInScope(page))
+                    this.request("request", request);
+            });
+            page.on("response", (response) => {
+                if (this.pageInScope(page))
+                    this.response(response);
+            });
+            page.on("requestfailed", (request) => {
+                if (this.pageInScope(page))
+                    this.request("request-failed", request);
+            });
+        }
+        if (this.enabled.has("websockets"))
+            page.on("websocket", (socket) => {
+                if (this.pageInScope(page))
+                    this.webSocket(page, socket);
+            });
+        if (this.enabled.has("frames")) {
+            page.on("frameattached", (frame) => {
+                if (this.pageInScope(page))
+                    this.frame("frame-attached", frame);
+            });
+            page.on("framedetached", (frame) => {
+                if (this.pageInScope(page))
+                    this.frame("frame-detached", frame);
+            });
+            page.on("framenavigated", (frame) => {
+                if (this.pageInScope(page))
+                    this.frame("frame-navigated", frame);
+            });
+        }
+        if (this.enabled.has("workers"))
+            page.on("worker", (worker) => {
+                if (this.pageInScope(page))
+                    this.worker(page, worker);
+            });
+        if (this.enabled.has("popups"))
+            page.on("popup", (popup) => {
+                if (this.pageInScope(page))
+                    this.popup(popup);
+            });
+        if (this.enabled.has("downloads"))
+            page.on("download", (download) => {
+                if (this.pageInScope(page))
+                    this.download(download);
+            });
+    }
+    pageInScope(page) {
+        try {
+            return this.allowedOrigins.has(new URL(page.url()).origin);
+        }
+        catch {
+            return false;
+        }
+    }
+    safeUrl(value) {
+        return sanitizeBrowserUrl(this.secrets.redact(value));
+    }
+    console(message) {
+        const location = message.location();
+        this.push({
+            kind: "console",
+            level: this.secrets.redact(message.type()).slice(0, 64),
+            text: this.secrets.redact(message.text()).slice(0, 65_536),
+            url: location.url === "" ? null : this.safeUrl(location.url),
+        });
+    }
+    request(kind, request) {
+        this.push({
+            kind,
+            method: this.secrets.redact(request.method()).slice(0, 32),
+            url: this.safeUrl(request.url()),
+            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
+            status: null,
+            header_names: Object.keys(request.headers())
+                .map((name) => this.secrets.redact(name).slice(0, 256))
+                .sort()
+                .slice(0, 256),
+            failure: kind === "request-failed"
+                ? this.secrets
+                    .redact(request.failure()?.errorText ?? "unknown")
+                    .slice(0, 1_024)
+                : null,
+        });
+    }
+    response(response) {
+        const request = response.request();
+        this.push({
+            kind: "response",
+            method: this.secrets.redact(request.method()).slice(0, 32),
+            url: this.safeUrl(response.url()),
+            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
+            status: response.status(),
+            header_names: Object.keys(response.headers())
+                .map((name) => this.secrets.redact(name).slice(0, 256))
+                .sort()
+                .slice(0, 256),
+            failure: null,
+        });
+    }
+    webSocket(page, socket) {
+        if (!this.admit("websockets", socket, this.limits.max_websockets))
+            return;
+        const url = this.safeUrl(socket.url());
+        this.push({ kind: "websocket-opened", url });
+        socket.on("framesent", ({ payload }) => {
+            if (this.pageInScope(page))
+                this.webSocketFrame("websocket-frame-sent", url, payload);
+        });
+        socket.on("framereceived", ({ payload }) => {
+            if (this.pageInScope(page))
+                this.webSocketFrame("websocket-frame-received", url, payload);
+        });
+        socket.on("close", () => {
+            if (this.pageInScope(page))
+                this.push({ kind: "websocket-closed", url });
+        });
+    }
+    webSocketFrame(kind, url, payload) {
+        const bytes = Buffer.byteLength(payload);
+        const isText = typeof payload === "string";
+        const text = isText ? this.secrets.redact(payload).slice(0, 65_536) : null;
+        this.push({
+            kind,
+            url,
+            payload_type: isText ? "text" : "binary",
+            payload_bytes: bytes,
+            payload_text: text,
+            truncated: isText && text !== null && text.length < payload.length,
+        });
+    }
+    frame(kind, frame) {
+        if (!this.admit("frames", frame, this.limits.max_frames))
+            return;
+        this.push({
+            kind,
+            url: frame.url() === "" ? null : this.safeUrl(frame.url()),
+            name: frame.name() === ""
+                ? null
+                : this.secrets.redact(frame.name()).slice(0, 1_024),
+        });
+    }
+    worker(page, worker) {
+        if (!this.admit("workers", worker, this.limits.max_workers))
+            return;
+        const details = {
+            url: this.safeUrl(worker.url()),
+            name: null,
+        };
+        this.push({ kind: "worker-created", ...details });
+        worker.on("close", () => {
+            if (this.pageInScope(page))
+                this.push({ kind: "worker-closed", ...details });
+        });
+    }
+    popup(page) {
+        if (!this.pageInScope(page)) {
+            void page.close().catch(() => undefined);
+            return;
+        }
+        if (!this.admit("popups", page, this.limits.max_popups))
+            return;
+        const opened = {
+            url: page.url() === "" ? null : this.safeUrl(page.url()),
+            name: null,
+        };
+        this.push({ kind: "popup-opened", ...opened });
+        page.on("close", () => this.pageInScope(page)
+            ? this.push({
+                kind: "popup-closed",
+                url: page.url() === "" ? null : this.safeUrl(page.url()),
+                name: null,
+            })
+            : undefined);
+        this.observePage(page);
+    }
+    download(download) {
+        this.push({
+            kind: "download-cancelled",
+            suggested_filename: this.secrets
+                .redact(download.suggestedFilename())
+                .slice(0, 1_024),
+            url: this.safeUrl(download.url()),
+        });
+        void download.cancel().catch(() => undefined);
+    }
+}