rea-agents 6.2.0 → 6.4.0

package/dist/browser/CdpWebMcpDiscovery.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
-import { inferJsonShape } from "../domain/jsonShape.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
+import { compositeKey } from "../domain/unicodeCodePointOrder.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
@@ -221,24 +223,29 @@ const assertStableAuthorizedFrame = async (context, initialUrl, origins) => {
 };
 const ingestWebMcpEvent = (options) => {
     const { event, input, frames, tools, completeness, transientFrames, resolvedTransientFrames, } = options;
+    if (event.method !== "WebMCP.toolsAdded" &&
+        event.method !== "WebMCP.toolsRemoved")
+        return;
     const params = recordValue(event.params);
-    if (params === undefined)
+    if (params === undefined) {
+        completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return;
+    }
     if (event.method === "WebMCP.toolsRemoved") {
-        for (const removed of recordsValue(params.tools)) {
+        for (const removed of webMcpEventTools(params.tools, completeness)) {
             const name = cdpStringValue(removed.name);
             const frameId = cdpStringValue(removed.frameId);
-            if (name === undefined || frameId === undefined)
+            if (name === undefined || frameId === undefined) {
+                completeness.exclude("webmcp_tools", "invalid_protocol_value");
                 continue;
+            }
             for (const [key, tool] of tools)
                 if (tool.name === name && tool.frame_id === frameId)
                     tools.delete(key);
         }
         return;
     }
-    if (event.method !== "WebMCP.toolsAdded")
-        return;
-    for (const declared of recordsValue(params.tools)) {
+    for (const declared of webMcpEventTools(params.tools, completeness)) {
         const frameId = cdpStringValue(declared.frameId);
         if (frameId !== undefined && transientFrames.has(frameId)) {
             if (!resolvedTransientFrames.has(frameId))
@@ -252,19 +259,40 @@ const ingestWebMcpEvent = (options) => {
         tools.set(normalized.tool_key, normalized);
     }
 };
+const webMcpEventTools = (value, completeness) => {
+    if (!Array.isArray(value)) {
+        completeness.exclude("webmcp_tools", "invalid_protocol_value");
+        return [];
+    }
+    const records = [];
+    for (const item of value) {
+        const record = recordValue(item);
+        if (record === undefined) {
+            completeness.exclude("webmcp_tools", "invalid_protocol_value");
+            continue;
+        }
+        records.push(record);
+    }
+    return records;
+};
 const normalizeTool = (value, input, frames, completeness) => {
     const frameId = cdpStringValue(value.frameId);
     const name = cdpStringValue(value.name);
     const frame = frameId === undefined ? undefined : frames.get(frameId);
-    if (frameId === undefined ||
-        name === undefined ||
-        frame?.origin === null ||
-        frame === undefined) {
+    if (frameId === undefined || name === undefined) {
+        completeness.exclude("webmcp_tools", "invalid_protocol_value");
+        return undefined;
+    }
+    if (frame?.origin === null || frame === undefined) {
         completeness.exclude("webmcp_tools", "out_of_target_scope");
         return undefined;
     }
     const description = cdpStringValue(value.description) ?? "";
     const annotations = recordValue(value.annotations);
+    const declaration = jsonValueSchema.safeParse(value.inputSchema);
+    if (!declaration.success)
+        completeness.exclude("webmcp_tools", "invalid_protocol_value");
+    const schema = declaration.success ? declaration.data : null;
     return {
         tool_key: toolKey(frame.url, frameId, name),
         name,
@@ -275,7 +303,10 @@ const normalizeTool = (value, input, frames, completeness) => {
         declaration_kind: numberValue(value.backendNodeId) === undefined
             ? "imperative"
             : "declarative",
-        input_schema_shape: schemaShape(value.inputSchema),
+        input_schema: schema,
+        input_schema_sha256: declaration.success
+            ? digestCanonicalValue(schema)
+            : null,
         annotations: {
             read_only: booleanOrNull(annotations?.readOnly),
             untrusted_content: booleanOrNull(annotations?.untrustedContent),
@@ -285,15 +316,6 @@ const normalizeTool = (value, input, frames, completeness) => {
         trust: "page-declared-untrusted",
     };
 };
-const schemaShape = (value) => {
-    if (recordValue(value) === undefined)
-        return null;
-    const encoded = JSON.stringify(value);
-    const shape = inferJsonShape(encoded);
-    if (shape === null)
-        throw new BrowserObservationError("inspect_web_page", "protocol_error");
-    return shape;
-};
 const registrationSource = (stack, allowedOrigins) => {
     const frame = recordsValue(stack?.callFrames)[0];
     const url = allowedSanitizedUrl(frame?.url, allowedOrigins);
@@ -327,8 +349,11 @@ const buildWebMcpResult = (options) => {
 };
 const toolKey = (frameUrl, frameId, name) => 
 // Registrations without a known admitted frame are excluded above, so the
-// frame ID here always distinguishes owners and keys cannot collapse.
-`webmcp_${createHash("sha256").update(`${frameUrl}\0${frameId}\0${name}`).digest("hex")}`;
+// frame ID here always distinguishes owners. Composite tuple keeps a NUL
+// inside one field from collapsing two registrations before hashing.
+`webmcp_${createHash("sha256")
+    .update(compositeKey([frameUrl, frameId, name]))
+    .digest("hex")}`;
 const booleanOrNull = (value) => typeof value === "boolean" ? value : null;
 const integerOrNull = (value) => {
     const number = numberValue(value);

package/dist/browser/ElectronFileScope.js

@@ -1,6 +1,7 @@
-import { realpath, stat } from "node:fs/promises";
-import { isAbsolute } from "node:path";
+import { open, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { admitAsarHeader, MAX_ASAR_HEADER_BYTES, } from "../artifacts/AsarHeader.js";
 /** Resolve one local file URL while rejecting remote hosts and encoded separators. */
 export const authorizedElectronFile = async (value) => {
     if (/%(?:2f|5c)/iu.test(value))
@@ -30,16 +31,105 @@ export const authorizedElectronFile = async (value) => {
     }
     if (!isAbsolute(path) || path.includes("\0"))
         return undefined;
-    let canonical;
     try {
-        if (!(await stat(path)).isFile())
-            return undefined;
-        canonical = await realpath(path);
+        if ((await stat(path)).isFile())
+            return await realpath(path);
     }
     catch (cause) {
-        // Missing or unreadable files cannot authorize a local file.
+        // Electron serves packaged pages from inside app.asar, which the host
+        // filesystem cannot stat; resolve those through the archive header below.
         void cause;
-        return undefined;
     }
-    return canonical;
+    return await authorizedAsarMember(path);
+};
+/**
+ * Resolve `<archive>.asar/<member>` the way Electron's file protocol does: the
+ * first `.asar` path component that is a regular file is the archive, and the
+ * remainder must name a regular file in its header (packed or unpacked).
+ */
+const authorizedAsarMember = async (path) => {
+    const segments = path.split(sep);
+    for (let index = 1; index < segments.length - 1; index += 1) {
+        if (!(segments[index] ?? "").toLowerCase().endsWith(".asar"))
+            continue;
+        const archive = segments.slice(0, index + 1).join(sep);
+        const member = segments.slice(index + 1);
+        if (member.some((part) => part === "" || part === "." || part === ".."))
+            return undefined;
+        try {
+            const metadata = await stat(archive);
+            if (!metadata.isFile())
+                continue;
+            const canonical = await realpath(archive);
+            const files = await asarFiles(canonical, metadata);
+            return isAsarRegularFile(files, member)
+                ? join(canonical, ...member)
+                : undefined;
+        }
+        catch (cause) {
+            // An unreadable or malformed archive cannot authorize its members.
+            void cause;
+            return undefined;
+        }
+    }
+    return undefined;
+};
+// This is a retained-memory budget for JSON headers, shared across all archives.
+const MAX_CACHED_HEADERS = 8;
+const headerCache = new Map();
+const archiveIdentity = (metadata) => `${String(metadata.dev)}:${String(metadata.ino)}:${String(metadata.size)}:${String(metadata.mtimeMs)}`;
+/** Read the two Chromium pickle headers on one handle before allocating JSON. */
+const asarFiles = async (archive, metadata) => {
+    const identity = archiveIdentity(metadata);
+    const cached = headerCache.get(archive);
+    if (cached?.identity === identity)
+        return cached.files;
+    const handle = await open(archive, "r");
+    let files;
+    let jsonBytes;
+    try {
+        const opened = await handle.stat();
+        if (!opened.isFile() || archiveIdentity(opened) !== identity)
+            throw new Error("ASAR identity changed before header read");
+        const admitted = await admitAsarHeader(handle);
+        jsonBytes = admitted.jsonBytes;
+        const json = Buffer.alloc(jsonBytes);
+        let offset = 0;
+        while (offset < json.length) {
+            const part = await handle.read(json, offset, json.length - offset, 16 + offset);
+            if (part.bytesRead === 0)
+                throw new Error("Truncated ASAR JSON header");
+            offset += part.bytesRead;
+        }
+        if (archiveIdentity(await handle.stat()) !== identity)
+            throw new Error("ASAR identity changed during header read");
+        const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(json));
+        if (!isRecord(parsed) || !isRecord(parsed.files))
+            throw new Error("ASAR header has no file tree");
+        files = parsed.files;
+    }
+    finally {
+        await handle.close();
+    }
+    headerCache.delete(archive);
+    headerCache.set(archive, { identity, files, bytes: jsonBytes });
+    const retainedBytes = () => [...headerCache.values()].reduce((sum, entry) => sum + entry.bytes, 0);
+    while (headerCache.size > MAX_CACHED_HEADERS ||
+        retainedBytes() > MAX_ASAR_HEADER_BYTES)
+        headerCache.delete(headerCache.keys().next().value ?? archive);
+    return files;
+};
+const isAsarRegularFile = (files, member) => {
+    let node = { files };
+    for (const part of member) {
+        const children = isRecord(node) ? node.files : undefined;
+        if (!isRecord(children) || !Object.hasOwn(children, part))
+            return false;
+        node = children[part];
+    }
+    return (isRecord(node) &&
+        typeof node.size === "number" &&
+        !("files" in node) &&
+        !("link" in node));
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -135,11 +135,14 @@ const globalCompleteness = (scenario, session, steps) => {
         missing.push("events");
     return classifyBrowserScenarioCompleteness(missing, truncated);
 };
-const runScenario = async (factory, scenario, options) => {
+const runScenario = async (openSession, scenario, options, retainCleanup) => {
     if (options.signal?.aborted === true)
         throw new BrowserObservationError(OPERATION, "cancelled");
     const startedAt = Date.now();
-    const session = await factory.open(scenario, options.signal === undefined ? {} : { signal: options.signal });
+    const session = await openSession(scenario, {
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+        retainCleanup,
+    });
     const steps = [];
     let operationOutcome = { ok: true };
     try {
@@ -172,6 +175,7 @@ const runScenario = async (factory, scenario, options) => {
     }
     catch (cause) {
         cleanupOutcome = { ok: false, cause };
+        retainCleanup(() => session.close());
     }
     if (!cleanupOutcome.ok) {
         const cleanup = browserScenarioCleanupObservation(cleanupOutcome.cause);
@@ -225,16 +229,34 @@ const runScenario = async (factory, scenario, options) => {
 };
 /** Controlled Playwright/CDP scenario driver with exact process ownership. */
 export class PlaywrightBrowserScenarioProvider {
-    factory;
-    constructor(factory) {
-        this.factory = factory;
+    openSession;
+    #tail = Promise.resolve();
+    #closing = false;
+    #closePromise;
+    #pendingCleanup = new Set();
+    constructor(openSession) {
+        this.openSession = openSession;
     }
     identity() {
         return PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY;
     }
-    async captureScenario(scenario, options = {}) {
+    captureScenario(scenario, options = {}) {
+        if (this.#closing)
+            return Promise.resolve(err(this.#closedError()));
+        const operation = this.#tail.then(() => this.#closing
+            ? err(this.#closedError())
+            : this.#captureScenario(scenario, options));
+        this.#tail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async #captureScenario(scenario, options) {
+        const pending = await this.#retryCleanup();
+        if (pending !== undefined)
+            return err(pending);
         try {
-            return ok(await runScenario(this.factory, scenario, options));
+            return ok(await runScenario(this.openSession, scenario, options, (close) => {
+                this.#pendingCleanup.add(close);
+            }));
         }
         catch (cause) {
             if (cause instanceof AnalysisError)
@@ -242,4 +264,38 @@ export class PlaywrightBrowserScenarioProvider {
             return err(new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, { cause }));
         }
     }
+    async close() {
+        this.#closing = true;
+        this.#closePromise ??= this.#tail
+            .then(async () => {
+            const failure = await this.#retryCleanup();
+            if (failure !== undefined)
+                throw failure;
+        })
+            .catch((cause) => {
+            this.#closePromise = undefined;
+            throw cause;
+        });
+        return this.#closePromise;
+    }
+    #closedError() {
+        return new BrowserObservationError(OPERATION, "cleanup_failed", {
+            detail: "Browser scenario provider is closing.",
+            cleanup: { reason: "Provider is closing", resources: [] },
+        });
+    }
+    async #retryCleanup() {
+        for (const pending of this.#pendingCleanup) {
+            try {
+                await pending();
+                this.#pendingCleanup.delete(pending);
+            }
+            catch (cause) {
+                return cause instanceof AnalysisError
+                    ? cause
+                    : new ProviderAdapterError(PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id, OPERATION, { cause });
+            }
+        }
+        return undefined;
+    }
 }

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -181,18 +181,23 @@ export class PlaywrightElectronActiveProvider {
         return outcome;
     }
 }
-const cleanupElectronProcesses = async (ownership, lineage) => {
-    if (process.platform === "win32") {
-        const root = await cleanupWindowsProcessTree(ownership.leaderPid);
-        if (!root.cleaned)
-            return root;
+/** Clean up an Electron launch. Windows signals a process only after lineage is verified. */
+export const cleanupElectronProcesses = async (ownership, lineage, host = {
+    platform: process.platform,
+    terminateTree: cleanupWindowsProcessTree,
+}) => {
+    if (host.platform === "win32") {
+        // An empty Windows process table is not ownership proof for this PID.
         if (lineage?.status !== "verified")
             return {
                 cleaned: false,
                 reason: "owned Electron lineage was unavailable; helper cleanup was not proven",
             };
+        const root = await host.terminateTree(ownership.leaderPid);
+        if (!root.cleaned)
+            return root;
         for (const descendant of lineage.lineage.descendants) {
-            const result = await cleanupWindowsProcessTree(descendant.pid);
+            const result = await host.terminateTree(descendant.pid);
             if (!result.cleaned)
                 return result;
         }

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -120,20 +120,20 @@ const captureStorage = async (input) => {
       }))()`));
         const value = {
             cookies: cookies.map((cookie) => ({
-                name: cookie.name,
-                domain: cookie.domain,
-                path: cookie.path,
+                name: secrets.redact(cookie.name),
+                domain: secrets.redact(cookie.domain),
+                path: secrets.redact(cookie.path),
                 secure: cookie.secure,
                 http_only: cookie.httpOnly,
                 same_site: cookie.sameSite,
                 ...secrets.fingerprint(cookie.value),
             })),
             local_storage: pageStorage.local_storage.map(([name, value]) => ({
-                name,
+                name: secrets.redact(name),
                 ...secrets.fingerprint(value),
             })),
             session_storage: pageStorage.session_storage.map(([name, value]) => ({
-                name,
+                name: secrets.redact(name),
                 ...secrets.fingerprint(value),
             })),
         };