rea-agents 2.3.0 → 2.5.0

package/dist/artifacts/ArtifactProvider.js

@@ -1,11 +1,13 @@
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
 import { inventoryArtifact } from "../application/ArtifactInventory.js";
 import { extractArtifact } from "../application/ArtifactExtraction.js";
-import { ARTIFACT_TOOL_CONTRACTS, artifactInventoryInputSchema, artifactExtractionInputSchema, } from "../contracts/artifactToolContracts.js";
+import { ARTIFACT_TOOL_CONTRACTS, artifactInspectionInputSchema, artifactInventoryInputSchema, artifactExtractionInputSchema, } from "../contracts/artifactToolContracts.js";
 import { AnalysisCapabilityUnavailableError, ArtifactOperationError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { ArtifactReaderFailure, } from "./ArtifactReader.js";
 import { ARTIFACT_GRAPH_PROVIDER } from "../application/InvestigationProviders.js";
+import { createEvidence } from "../domain/evidence.js";
+import { createArtifactInspection } from "../domain/artifactInspection.js";
 const IDENTITY = Object.freeze(ARTIFACT_GRAPH_PROVIDER);
 /** Read-only inventory and exclusively owned extraction provider. */
 export class ArtifactProvider {
@@ -22,7 +24,9 @@ export class ArtifactProvider {
         outputContractVersion: 1,
         available: true,
         reason: null,
-        pagination: "offset",
+        pagination: contract.name === "inspect_artifact"
+            ? "none"
+            : "offset",
         exhaustive: false,
         effects: Object.freeze({
             mutatesArtifact: false,
@@ -68,6 +72,10 @@ class ArtifactClient {
         if (!isArtifactOperation(operation))
             return err(new AnalysisCapabilityUnavailableError(IDENTITY.id, operation, "Operation is not implemented by artifact graph provider."));
         try {
+            if (operation === "inspect_artifact") {
+                const inspected = await this.inspectArtifact(parameters, options);
+                return inspected;
+            }
             if (operation === "extract_artifact") {
                 const parsed = artifactExtractionInputSchema.parse(parameters);
                 const result = await extractArtifact({
@@ -90,26 +98,7 @@ class ArtifactClient {
                 }));
             }
             const parsed = artifactInventoryInputSchema.parse(parameters);
-            const result = await inventoryArtifact(this.target.sourcePath ?? this.target.path, limitsFrom(parsed), {
-                nodeOffset: parsed.node_offset,
-                nodeLimit: parsed.node_limit,
-                occurrenceOffset: parsed.occurrence_offset,
-                occurrenceLimit: parsed.occurrence_limit,
-                edgeOffset: parsed.edge_offset,
-                edgeLimit: parsed.edge_limit,
-            }, {
-                ...(options?.signal === undefined ? {} : { signal: options.signal }),
-                nativeMount: {
-                    nativeMountApproved: parsed.native_mount_approved === true,
-                    nativeMountEnabled: this.nativeMountEnabled,
-                },
-                integrity: {
-                    mode: parsed.integrity_policy,
-                    approved: parsed.integrity_continue_approved === true,
-                    enabled: this.integrityContinueEnabled,
-                    maxMismatches: parsed.max_integrity_mismatches,
-                },
-            });
+            const result = await this.inventory(parsed, options);
             return ok(createAnalysisExecution(result, IDENTITY, {
                 rawResult: null,
                 limitations: result.limitations,
@@ -127,6 +116,82 @@ class ArtifactClient {
     close() {
         return Promise.resolve();
     }
+    async inspectArtifact(parameters, options) {
+        const parsed = artifactInspectionInputSchema.parse(parameters);
+        const inventoryParameters = artifactInventoryInputSchema.parse({
+            node_offset: 0,
+            node_limit: parsed.max_observations,
+            occurrence_offset: 0,
+            occurrence_limit: parsed.max_observations,
+            edge_offset: 0,
+            edge_limit: parsed.max_relationships,
+            native_mount_approved: parsed.native_mount_approved,
+            integrity_policy: parsed.integrity_policy,
+            integrity_continue_approved: parsed.integrity_continue_approved,
+            max_integrity_mismatches: parsed.max_integrity_mismatches,
+            max_entries: parsed.max_entries,
+            max_total_bytes: parsed.max_total_bytes,
+            max_entry_bytes: parsed.max_entry_bytes,
+            max_compression_ratio: parsed.max_compression_ratio,
+            max_depth: parsed.max_depth,
+            max_path_bytes: parsed.max_path_bytes,
+        });
+        await options?.progress?.report({
+            phase: "inspect_artifact.inventory",
+            completed: 0,
+            total: 1,
+            message: "inventory substep started",
+        });
+        const inventory = await this.inventory(inventoryParameters, options);
+        const subject = subjectFor(this.target.sourcePath ?? this.target.path, inventory.manifest);
+        const locations = inventory.occurrences.items.map(({ logical_path: path }) => ({
+            kind: "artifact-path",
+            path,
+        }));
+        const inventoryEvidence = createEvidence(subject, IDENTITY, {
+            operation: "inventory_artifact",
+            parameters: inventoryParameters,
+            result: inventory,
+            rawResult: null,
+            limitations: inventory.limitations,
+            locations,
+        });
+        const result = createArtifactInspection(inventoryEvidence, parsed);
+        await options?.progress?.report({
+            phase: "inspect_artifact.inventory",
+            completed: 1,
+            total: 1,
+            message: "inventory substep completed",
+        });
+        return ok(createAnalysisExecution(result, IDENTITY, {
+            rawResult: null,
+            limitations: result.limitations,
+            subject,
+            locations,
+        }));
+    }
+    inventory(parsed, options) {
+        return inventoryArtifact(this.target.sourcePath ?? this.target.path, limitsFrom(parsed), {
+            nodeOffset: parsed.node_offset,
+            nodeLimit: parsed.node_limit,
+            occurrenceOffset: parsed.occurrence_offset,
+            occurrenceLimit: parsed.occurrence_limit,
+            edgeOffset: parsed.edge_offset,
+            edgeLimit: parsed.edge_limit,
+        }, {
+            ...(options?.signal === undefined ? {} : { signal: options.signal }),
+            nativeMount: {
+                nativeMountApproved: parsed.native_mount_approved === true,
+                nativeMountEnabled: this.nativeMountEnabled,
+            },
+            integrity: {
+                mode: parsed.integrity_policy,
+                approved: parsed.integrity_continue_approved === true,
+                enabled: this.integrityContinueEnabled,
+                maxMismatches: parsed.max_integrity_mismatches,
+            },
+        });
+    }
 }
 const limitsFrom = (input) => ({
     maxEntries: input.max_entries,

package/dist/browser/BrowserScenarioSecrets.js

@@ -0,0 +1,53 @@
+import { createHash } from "node:crypto";
+const REDACTION_PREFIX = "[REDACTED:";
+/** Resolved secret values kept only for one in-memory scenario session. */
+export class BrowserScenarioSecrets {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    static resolve(scenario, environment) {
+        const values = new Map();
+        for (const declaration of scenario.secrets) {
+            const value = environment[declaration.environment_variable];
+            if (value === undefined)
+                return undefined;
+            values.set(declaration.secret_id, value);
+        }
+        return new BrowserScenarioSecrets(values);
+    }
+    value(source) {
+        if (source.source === "literal")
+            return source.value;
+        const value = this.values.get(source.secret_id);
+        if (value === undefined)
+            throw new Error("Validated browser secret was not resolved");
+        return value;
+    }
+    url(destination) {
+        const url = new URL(destination.url);
+        for (const { name, value } of destination.query)
+            url.searchParams.append(name, this.value(value));
+        return url.href;
+    }
+    redact(value) {
+        let output = value;
+        const replacements = [...this.values].sort(([leftId, left], [rightId, right]) => right.length - left.length ||
+            (leftId < rightId ? -1 : leftId > rightId ? 1 : 0));
+        for (const [id, secret] of replacements)
+            if (secret !== "")
+                output = output.replaceAll(secret, `${REDACTION_PREFIX}${id}]`);
+        return output;
+    }
+    fingerprint(value) {
+        for (const secret of this.values.values())
+            if (secret !== "" && value.includes(secret))
+                return { value_state: "redacted-secret", value_sha256: null };
+        return {
+            value_state: "hashed",
+            value_sha256: createHash("sha256")
+                .update(this.redact(value))
+                .digest("hex"),
+        };
+    }
+}

package/dist/browser/BrowserScenarioSessionPort.js

@@ -0,0 +1 @@
+export {};

package/dist/browser/CdpBrowserProvider.js

@@ -3,7 +3,7 @@ import { analyzeCapturedWebBundle } from "../domain/webBundleAnalyzer.js";
 import { webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { webObservationSessionSchema, } from "../domain/browserSession.js";
 import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { compareWebCaptures, webCaptureDiffSchema, } from "../domain/webCaptureDiff.js";
+import { browserCaptureComparisonSchema, compareBrowserCaptures, } from "../domain/browserCaptureComparison.js";
 import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
@@ -136,7 +136,7 @@ export class CdpBrowserProvider {
     }
     async compareCaptures(input) {
         try {
-            return ok(webCaptureDiffSchema.parse(compareWebCaptures(input)));
+            return ok(browserCaptureComparisonSchema.parse(compareBrowserCaptures(input)));
         }
         catch (cause) {
             return err(providerError(cause, "compare_web_captures"));

package/dist/browser/CdpCaptureDocuments.js

@@ -156,6 +156,10 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
 };
 export const captureAccessibility = (results, maximum, options) => {
     const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
+    const nodeIds = new Set(all.flatMap((node) => {
+        const nodeId = stringValue(node.nodeId);
+        return nodeId === undefined ? [] : [nodeId];
+    }));
     let retainedBytes = 0;
     let excludedFields = 0;
     let truncatedFields = 0;
@@ -187,6 +191,7 @@ export const captureAccessibility = (results, maximum, options) => {
             name: captureText(node.name),
             description: captureText(node.description),
             ignored: node.ignored === true,
+            states: accessibilityStates(node.properties),
         };
     });
     for (const node of all.slice(maximum)) {
@@ -201,6 +206,11 @@ export const captureAccessibility = (results, maximum, options) => {
     return {
         total: all.length,
         nodes,
+        treeIncomplete: all.some((node) => Array.isArray(node.childIds) &&
+            node.childIds.some((childId) => {
+                const id = stringValue(childId);
+                return id !== undefined && !nodeIds.has(id);
+            })),
         textCapture: {
             status: options.unavailable
                 ? "unavailable"
@@ -215,6 +225,53 @@ export const captureAccessibility = (results, maximum, options) => {
         },
     };
 };
+const ACCESSIBILITY_STATE_NAMES = new Set([
+    "atomic",
+    "autocomplete",
+    "busy",
+    "checked",
+    "disabled",
+    "editable",
+    "expanded",
+    "focusable",
+    "focused",
+    "hasPopup",
+    "hidden",
+    "invalid",
+    "level",
+    "live",
+    "modal",
+    "multiline",
+    "multiselectable",
+    "orientation",
+    "pressed",
+    "readonly",
+    "required",
+    "selected",
+    "valuemax",
+    "valuemin",
+]);
+const accessibilityStates = (value) => {
+    const states = new Map();
+    for (const property of recordsValue(value)) {
+        const name = stringValue(property.name);
+        if (name === undefined || !ACCESSIBILITY_STATE_NAMES.has(name))
+            continue;
+        const raw = recordValue(property.value)?.value;
+        const state = typeof raw === "boolean"
+            ? raw
+            : typeof raw === "number"
+                ? numberValue(raw)
+                : typeof raw === "string"
+                    ? raw.slice(0, 256)
+                    : undefined;
+        if (state !== undefined)
+            states.set(name, state);
+    }
+    return [...states]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, state]) => ({ name, value: state }));
+};
 const axText = (value) => boundedText(recordValue(value)?.value, 1_024);
 const indexedString = (strings, index) => {
     const integer = numberValue(index);

package/dist/browser/CdpCaptureStorage.js

@@ -1,53 +1,95 @@
 import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
+import { captureStorageFingerprints, } from "./CdpCaptureStorageFingerprints.js";
 import { numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 /** Capture redacted, bounded storage metadata for one authorized origin. */
 export const captureStorage = async (context, origin, limitations) => {
     const quota = recordValue(await optionalCdpCommand(context, "Storage.getUsageAndQuota", { origin }, limitations));
     const local = context.input.include_storage_keys
-        ? await storageKeys(context, origin, true, limitations)
-        : [];
+        ? await storageItems(context, origin, true, limitations)
+        : emptyStorageItems;
     const session = context.input.include_storage_keys
-        ? await storageKeys(context, origin, false, limitations)
-        : [];
-    const indexed = context.input.include_storage_keys
-        ? stringArray(recordValue(await optionalCdpCommand(context, "IndexedDB.requestDatabaseNames", { securityOrigin: origin }, limitations))?.databaseNames)
-        : [];
-    const caches = context.input.include_storage_keys
-        ? recordsValue(recordValue(await optionalCdpCommand(context, "CacheStorage.requestCacheNames", { securityOrigin: origin }, limitations))?.caches).flatMap((cache) => {
-            const name = stringValue(cache.cacheName);
-            return name === undefined ? [] : [name.slice(0, 1_024)];
-        })
-        : [];
+        ? await storageItems(context, origin, false, limitations)
+        : emptyStorageItems;
+    const indexedRaw = context.input.include_storage_keys
+        ? await optionalCdpCommand(context, "IndexedDB.requestDatabaseNames", { securityOrigin: origin }, limitations)
+        : undefined;
+    const indexedValues = recordValue(indexedRaw)?.databaseNames;
+    const indexed = stringArray(indexedValues);
+    const cacheRaw = context.input.include_storage_keys
+        ? await optionalCdpCommand(context, "CacheStorage.requestCacheNames", { securityOrigin: origin }, limitations)
+        : undefined;
+    const cacheValues = recordsValue(recordValue(cacheRaw)?.caches);
+    const caches = capturedCaches(cacheValues);
     const maximum = context.input.limits.max_storage_keys;
+    const fingerprints = context.input.include_storage_fingerprints
+        ? await captureStorageFingerprints({
+            context,
+            origin,
+            local,
+            session,
+            indexedDbNames: indexed.slice(0, maximum),
+            caches: caches.slice(0, maximum),
+            limitations,
+        })
+        : { items: [], complete: false, truncated: false };
+    const truncated = [local.items, session.items, indexed, caches].some((items) => items.length > maximum) || fingerprints.truncated;
+    const structuredStorageComplete = indexedRaw !== undefined &&
+        Array.isArray(indexedValues) &&
+        indexed.length === indexedValues.length &&
+        cacheRaw !== undefined &&
+        caches.length === cacheValues.length;
     return {
         value: {
             origin,
             usage_bytes: numberValue(quota?.usage) ?? null,
             quota_bytes: numberValue(quota?.quota) ?? null,
-            local_storage_keys: local.slice(0, maximum),
-            session_storage_keys: session.slice(0, maximum),
-            indexed_db_names: indexed.slice(0, maximum),
-            cache_names: caches.slice(0, maximum),
+            local_storage_keys: local.items
+                .map(({ key }) => key.slice(0, 1_024))
+                .slice(0, maximum),
+            session_storage_keys: session.items
+                .map(({ key }) => key.slice(0, 1_024))
+                .slice(0, maximum),
+            indexed_db_names: indexed
+                .map((name) => name.slice(0, 1_024))
+                .slice(0, maximum),
+            cache_names: caches
+                .map(({ name }) => name.slice(0, 1_024))
+                .slice(0, maximum),
+            content_fingerprints: [...fingerprints.items],
+            fingerprint_algorithm: "sha256",
+            fingerprints_complete: fingerprints.complete && structuredStorageComplete && !truncated,
             values_redacted: true,
         },
-        truncated: [local, session, indexed, caches].some((items) => items.length > maximum),
+        truncated,
     };
 };
-const storageKeys = async (context, origin, isLocalStorage, limitations) => {
-    const result = recordValue(await optionalCdpCommand(context, "DOMStorage.getDOMStorageItems", { storageId: { securityOrigin: origin, isLocalStorage } }, limitations));
-    return Array.isArray(result?.entries)
-        ? result.entries.flatMap((entry) => {
-            if (!Array.isArray(entry))
-                return [];
-            const key = stringValue(entry[0]);
-            return key === undefined ? [] : [key.slice(0, 1_024)];
-        })
-        : [];
+const emptyStorageItems = {
+    items: [],
+    complete: false,
+};
+const capturedCaches = (values) => values.flatMap((cache) => {
+    const name = stringValue(cache.cacheName);
+    const id = stringValue(cache.cacheId);
+    return name === undefined || id === undefined ? [] : [{ name, id }];
+});
+const storageItems = async (context, origin, isLocalStorage, limitations) => {
+    const raw = await optionalCdpCommand(context, "DOMStorage.getDOMStorageItems", { storageId: { securityOrigin: origin, isLocalStorage } }, limitations);
+    const entries = recordValue(raw)?.entries;
+    if (raw === undefined || !Array.isArray(entries))
+        return { items: [], complete: false };
+    const items = entries.flatMap((entry) => {
+        if (!Array.isArray(entry))
+            return [];
+        const key = stringValue(entry[0]);
+        const value = stringValue(entry[1]);
+        return key === undefined || value === undefined ? [] : [{ key, value }];
+    });
+    return { items, complete: items.length === entries.length };
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.flatMap((item) => {
         const text = stringValue(item);
-        return text === undefined ? [] : [text.slice(0, 1_024)];
+        return text === undefined ? [] : [text];
     })
     : [];