rea-agents 3.2.1 → 4.0.1

package/dist/domain/artifactInspection.js

@@ -4,18 +4,19 @@ import { z } from "zod";
 import { artifactInventoryResultSchema, } from "./artifactGraph.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { jsonValueSchema } from "./jsonValue.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
 const textSchema = z.string().min(1);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const artifactIdSchema = z.string().regex(/^art_[a-f0-9]{64}$/u);
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const artifactIdSchema = prefixedDigestSchema("art");
 const inspectionObservationSchema = z.strictObject({
-    observation_id: z.string().regex(/^aio_[a-f0-9]{64}$/u),
+    observation_id: prefixedDigestSchema("aio"),
     kind: z.enum(["root-manifest", "artifact", "occurrence", "integrity"]),
     subject: textSchema,
     value: jsonValueSchema,
     evidence_id: evidenceIdSchema,
 });
 const inspectionRelationshipSchema = z.strictObject({
-    relationship_id: z.string().regex(/^air_[a-f0-9]{64}$/u),
+    relationship_id: prefixedDigestSchema("air"),
     relation: z.enum([
         "contains",
         "extracts",
@@ -27,21 +28,21 @@ const inspectionRelationshipSchema = z.strictObject({
     ]),
     source_artifact_id: artifactIdSchema,
     target_artifact_id: artifactIdSchema,
-    occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
+    occurrence_id: prefixedDigestSchema("occ"),
     logical_path: textSchema.nullable(),
     evidence_id: evidenceIdSchema,
 });
 const inspectionHypothesisSchema = z.strictObject({
-    hypothesis_id: z.string().regex(/^aih_[a-f0-9]{64}$/u),
+    hypothesis_id: prefixedDigestSchema("aih"),
     statement: textSchema,
     confidence: z.enum(["medium", "low"]),
     basis_evidence_ids: z.array(evidenceIdSchema).min(1),
     limitation: textSchema,
 });
 const inspectionContradictionSchema = z.strictObject({
-    contradiction_id: z.string().regex(/^aic_[a-f0-9]{64}$/u),
+    contradiction_id: prefixedDigestSchema("aic"),
     statement: textSchema,
-    occurrence_id: z.string().regex(/^occ_[a-f0-9]{64}$/u),
+    occurrence_id: prefixedDigestSchema("occ"),
     declared_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     observed_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     evidence_id: evidenceIdSchema,
@@ -57,7 +58,7 @@ const nextProbeSchema = z.strictObject({
     ]),
 });
 const unexploredBranchSchema = z.strictObject({
-    branch_id: z.string().regex(/^aib_[a-f0-9]{64}$/u),
+    branch_id: prefixedDigestSchema("aib"),
     reason: z.enum(["format-specific-analysis-required", "unknown-format"]),
     detail: textSchema,
     next_probe: nextProbeSchema.nullable(),
@@ -65,16 +66,16 @@ const unexploredBranchSchema = z.strictObject({
 });
 /** Provider-neutral inspection result with its atomic source Evidence. */
 export const artifactInspectionResultSchema = z.strictObject({
-    inspection_id: z.string().regex(/^ai_[a-f0-9]{64}$/u),
+    inspection_id: prefixedDigestSchema("ai"),
     subject: z.strictObject({
-        manifest_id: z.string().regex(/^agm_[a-f0-9]{64}$/u),
+        manifest_id: prefixedDigestSchema("agm"),
         root_artifact_id: artifactIdSchema,
         root_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
         root_format: textSchema,
     }),
     substeps: z
         .array(z.strictObject({
-        substep_id: z.string().regex(/^ais_[a-f0-9]{64}$/u),
+        substep_id: prefixedDigestSchema("ais"),
         operation: z.literal("inventory_artifact"),
         status: z.literal("completed"),
         evidence_id: evidenceIdSchema,

package/dist/domain/binaryTarget.js

@@ -1,14 +1,15 @@
 import { err, ok } from "./result.js";
+import { mzWindowsHeaderOffset, parseDosMzHeader } from "./dosMz.js";
 /**
  * Parse supported executable headers without I/O. The caller supplies the host
  * architecture used for deterministic FAT Mach-O slice selection.
  */
-export const parseExecutableHeader = (bytes, hostArchitecture) => {
+export const parseExecutableHeader = (bytes, hostArchitecture, fileSize = bytes.length) => {
     if (bytes.length >= 4 &&
         bytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
         return parseElf(bytes);
     if (bytes.length >= 2 && bytes[0] === 0x4d && bytes[1] === 0x5a)
-        return parsePe(bytes);
+        return parseMz(bytes, fileSize);
     if (bytes.length < 8)
         return err("truncated or unsupported binary header");
     const magic = bytes.readUInt32BE(0);
@@ -82,13 +83,24 @@ const parseElf = (bytes) => {
         availableArchitectures: [architecture],
     });
 };
-const parsePe = (bytes) => {
-    if (bytes.length < 64)
-        return err("truncated PE DOS header");
-    const offset = bytes.readUInt32LE(0x3c);
-    if (offset > bytes.length - 24)
-        return err("invalid or truncated PE header");
-    return parsePeRecord(bytes.subarray(offset));
+const parseMz = (bytes, fileSize) => {
+    const offset = mzWindowsHeaderOffset(bytes);
+    if (offset !== null) {
+        if (offset < 64 || offset > bytes.length - 24)
+            return err("invalid or truncated Windows executable header in MZ image");
+        const signature = bytes.toString("ascii", offset, offset + 2);
+        if (["NE", "LE", "LX"].includes(signature))
+            return err(`unsupported ${signature} executable in MZ image`);
+        return parsePeRecord(bytes.subarray(offset));
+    }
+    const parsed = parseDosMzHeader(bytes, fileSize);
+    return parsed.ok
+        ? ok({
+            format: "dos-mz",
+            architecture: "x86",
+            availableArchitectures: ["x86"],
+        })
+        : parsed;
 };
 /** Parse a bounded PE signature, COFF record, and optional header without I/O. */
 export const parsePeRecord = (record) => {
@@ -173,6 +185,8 @@ const peArchitecture = (machine) => {
         case 0x8664:
             return "x86_64";
         case 0x1c0:
+        case 0x1c2:
+        case 0x1c4:
             return "arm";
         case 0xaa64:
             return "arm64";

package/dist/domain/browserObservation.js

@@ -66,13 +66,13 @@ export const browserEndpointSchema = z
 });
 export const browserAllowedOriginsSchema = z
     .array(browserOriginSchema)
-    .min(1)
-    .transform((origins) => Array.from(new Set(origins)).sort());
+    .transform((origins) => Array.from(new Set(origins)).sort())
+    .default([]);
 const browserInput = {
     cdp_endpoint: browserEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
 };
-/** Public input for complete discovery of allowed page targets. */
+/** Public input for complete discovery, optionally filtered by exact origin. */
 export const listBrowserTargetsInputSchema = z.object({
     ...browserInput,
 });
@@ -116,7 +116,7 @@ export const sanitizedBrowserUrlSchema = z.object({
     query_parameter_names: z.array(z.string()),
     redacted: z.boolean(),
 });
-/** Remove credentials and query values before a browser URL becomes durable. */
+/** Preserve local URL data while removing only URL userinfo credentials. */
 export const sanitizeBrowserUrl = (value) => {
     let parsed;
     try {
@@ -124,38 +124,57 @@ export const sanitizeBrowserUrl = (value) => {
     }
     catch {
         return {
-            url: "[unsupported-url]",
+            url: value,
             origin: null,
             query_parameter_names: [],
-            redacted: true,
+            redacted: false,
         };
     }
     const hadCredentials = parsed.username !== "" || parsed.password !== "";
-    const hadFragment = parsed.hash !== "";
-    const names = [...new Set(parsed.searchParams.keys())].sort();
-    parsed.username = "";
-    parsed.password = "";
-    parsed.hash = "";
-    parsed.search = "";
-    for (const name of names)
-        parsed.searchParams.append(name, "[REDACTED]");
+    const names = [...parsed.searchParams.keys()];
+    const sanitizedUrl = hadCredentials
+        ? removeUrlUserInfo(value, parsed)
+        : value;
     return {
-        url: parsed.href,
+        url: sanitizedUrl,
         origin: parsed.origin === "null" ? null : parsed.origin,
         query_parameter_names: names,
-        redacted: hadCredentials || hadFragment || names.length > 0,
+        redacted: hadCredentials,
     };
 };
-/** Remove credentials, fragments, and query values from endpoint candidates. */
-export const sanitizeEndpointCandidate = (value) => {
+const removeUrlUserInfo = (value, parsed) => {
+    const schemeSeparator = value.indexOf("://");
+    const authorityStart = schemeSeparator < 0
+        ? value.startsWith("//")
+            ? 2
+            : -1
+        : schemeSeparator + 3;
+    if (authorityStart < 0)
+        return credentialFreeHref(parsed);
+    const remaining = value.slice(authorityStart);
+    const delimiter = remaining.search(/[/?#]/u);
+    const authorityEnd = delimiter < 0 ? value.length : authorityStart + delimiter;
+    const authority = value.slice(authorityStart, authorityEnd);
+    const userInfoEnd = authority.lastIndexOf("@");
+    if (userInfoEnd < 0)
+        return credentialFreeHref(parsed);
+    const candidate = `${value.slice(0, authorityStart)}${authority.slice(userInfoEnd + 1)}${value.slice(authorityEnd)}`;
     try {
-        const parsed = new URL(value, "https://rea.invalid");
-        const sanitized = sanitizeBrowserUrl(parsed.href).url;
-        return parsed.origin === "https://rea.invalid"
-            ? sanitized.replace("https://rea.invalid", "")
-            : sanitized;
+        const candidateUrl = new URL(candidate);
+        return candidateUrl.username === "" && candidateUrl.password === ""
+            ? candidate
+            : credentialFreeHref(parsed);
     }
     catch {
-        return value.split("#", 1)[0]?.split("?", 1)[0] ?? "";
+        return credentialFreeHref(parsed);
     }
 };
+const credentialFreeHref = (parsed) => {
+    parsed.username = "";
+    parsed.password = "";
+    return parsed.href;
+};
+/** Normalize endpoint candidates without discarding local query or fragment data. */
+export const sanitizeEndpointCandidate = (value) => {
+    return sanitizeBrowserUrl(value).url;
+};

package/dist/domain/browserObservationSchemas.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { webTextArtifactSchema } from "./webContentArtifact.js";
 import { jsonShapeSchema } from "./jsonShape.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
 const browserVersionSchema = z.object({
     product: z.string(),
     protocol_version: z.string(),
@@ -88,7 +89,7 @@ const browserScriptSchema = z.object({
     source: browserScriptSourceSchema,
 });
 const browserResourceSchema = z.object({
-    resource_key: z.string().regex(/^res_[a-f0-9]{64}$/u),
+    resource_key: prefixedDigestSchema("res"),
     url: z.string(),
     origin: z.string().nullable(),
     type: z.string(),

package/dist/domain/browserScenario.js

@@ -1,22 +1,19 @@
 import { z } from "zod";
-import { browserScenarioActionSchema, browserScenarioAllowedOriginsSchema, browserScenarioBrowserSchema, browserScenarioCaptureSchema, browserScenarioEnvironmentSchema, browserScenarioRedactionSchema, browserScenarioRequestReplaySchema, browserScenarioSecretSchema, browserScenarioStorageSchema, browserScenarioUrlSchema, } from "./browserScenarioValues.js";
+import { browserScenarioActionSchema, browserScenarioBrowserSchema, browserScenarioCaptureSchema, browserScenarioEnvironmentSchema, browserScenarioSecretSchema, browserScenarioStorageSchema, browserScenarioUrlSchema, } from "./browserScenarioValues.js";
 export { browserScenarioActionSchema, browserScenarioUrlSchema, browserScenarioValueSchema, } from "./browserScenarioValues.js";
 export const browserScenarioInputSchema = z.strictObject({
-    browser: browserScenarioBrowserSchema.describe("Required launch/connect authority. Launch uses the approved executable and an owned temporary profile; connect uses one approved loopback CDP endpoint and target."),
+    browser: browserScenarioBrowserSchema.describe("Required launch/connect selection. Launch uses the selected executable and an owned temporary profile; connect uses one loopback CDP endpoint and target."),
     start_url: browserScenarioUrlSchema.describe("Required initial HTTP(S) URL. Query values must be declared separately as public literals or secret references."),
-    allowed_origins: browserScenarioAllowedOriginsSchema.describe("Required exact HTTP(S) origins for the start URL and every later navigation, storage seed, and replay route."),
     environment: browserScenarioEnvironmentSchema,
     actions: z
         .array(browserScenarioActionSchema)
         .min(1)
         .describe("Required sequence of explicit browser actions."),
     storage: browserScenarioStorageSchema,
-    request_replay: browserScenarioRequestReplaySchema,
     secrets: z
         .array(browserScenarioSecretSchema)
         .default([])
-        .describe("Optional references to approved environment variables. Secret values are never supplied inline; declarations are required only when an action, URL, storage value, or replay route references a secret."),
-    redaction: browserScenarioRedactionSchema,
+        .describe("Optional environment-variable references for values used in actions, URLs, storage, or replay, and for redacting matching observed text. Secret values are never supplied inline."),
     capture: browserScenarioCaptureSchema,
 });
 const addIssue = (context, path, message) => context.addIssue({ code: "custom", path, message });
@@ -24,11 +21,6 @@ const assertUnique = (values, path, label, context) => {
     if (new Set(values).size !== values.length)
         addIssue(context, path, `${label} must be unique`);
 };
-const originFor = (destination) => new URL(destination.url).origin;
-const assertAllowedDestination = (destination, allowedOrigins, path, context) => {
-    if (!allowedOrigins.has(originFor(destination)))
-        addIssue(context, path, `URL origin ${originFor(destination)} is not declared in allowed_origins`);
-};
 const secretReferencesInValue = (value) => (value?.source === "secret" ? [value.secret_id] : []);
 const destinationSecretReferences = (destination) => destination.query.flatMap(({ value }) => secretReferencesInValue(value));
 const actionSecretReferences = (action) => {
@@ -38,125 +30,33 @@ const actionSecretReferences = (action) => {
         return destinationSecretReferences(action.destination);
     return [];
 };
-const validateStorage = (scenario, allowedOrigins, context) => {
+const validateStorage = (scenario) => {
     const references = [];
-    scenario.storage.cookies.forEach((cookie, index) => {
-        assertAllowedDestination(cookie.destination, allowedOrigins, ["storage", "cookies", index, "destination"], context);
+    scenario.storage.cookies.forEach((cookie) => {
         references.push(...secretReferencesInValue(cookie.value));
         references.push(...destinationSecretReferences(cookie.destination));
     });
     for (const collection of ["local_storage", "session_storage"])
-        scenario.storage[collection].forEach((storage, index) => {
-            if (!allowedOrigins.has(storage.origin))
-                addIssue(context, ["storage", collection, index, "origin"], `Storage origin ${storage.origin} is not declared in allowed_origins`);
+        scenario.storage[collection].forEach((storage) => {
             for (const entry of storage.entries)
                 references.push(...secretReferencesInValue(entry.value));
         });
     return references;
 };
-const SENSITIVE_HEADERS = new Set([
-    "authorization",
-    "cookie",
-    "proxy-authorization",
-    "set-cookie",
-]);
-const FORBIDDEN_REPLAY_HEADERS = new Set([
-    "content-length",
-    "location",
-    "transfer-encoding",
-]);
-const validateRequestReplay = (scenario, allowedOrigins, context) => {
-    if (scenario.request_replay.mode === "disabled")
-        return [];
-    assertUnique(scenario.request_replay.routes.map(({ route_id: id }) => id), ["request_replay", "routes"], "Replay route IDs", context);
-    assertUnique(scenario.request_replay.routes.map(({ method, request }) => `${method} ${request.url}?${request.query
-        .map(({ name, value }) => value.source === "secret"
-        ? `${name}=\${secret:${value.secret_id}}`
-        : `${name}=${value.value}`)
-        .join("&")}`), ["request_replay", "routes"], "Replay request matchers", context);
-    const references = [];
-    scenario.request_replay.routes.forEach((route, routeIndex) => {
-        assertAllowedDestination(route.request, allowedOrigins, ["request_replay", "routes", routeIndex, "request"], context);
-        references.push(...destinationSecretReferences(route.request));
-        if (route.response.kind === "redirect") {
-            assertAllowedDestination(route.response.destination, allowedOrigins, ["request_replay", "routes", routeIndex, "response", "destination"], context);
-            references.push(...destinationSecretReferences(route.response.destination));
-            return;
-        }
-        assertUnique(route.response.headers.map(({ name }) => name.toLowerCase()), ["request_replay", "routes", routeIndex, "response", "headers"], "Replay response header names", context);
-        route.response.headers.forEach((header, headerIndex) => {
-            if (FORBIDDEN_REPLAY_HEADERS.has(header.name))
-                addIssue(context, [
-                    "request_replay",
-                    "routes",
-                    routeIndex,
-                    "response",
-                    "headers",
-                    headerIndex,
-                ], `Replay header ${header.name} must be modeled by the provider`);
-            if (SENSITIVE_HEADERS.has(header.name) &&
-                header.value.source === "literal")
-                addIssue(context, [
-                    "request_replay",
-                    "routes",
-                    routeIndex,
-                    "response",
-                    "headers",
-                    headerIndex,
-                    "value",
-                ], `Credential header ${header.name} requires a declared secret`);
-            references.push(...secretReferencesInValue(header.value));
-        });
-        references.push(...secretReferencesInValue(route.response.body));
-    });
-    return references;
-};
 const validateSecretReferences = (scenario, references, context) => {
     const declared = new Set(scenario.secrets.map(({ secret_id: id }) => id));
     for (const reference of references)
         if (!declared.has(reference))
             addIssue(context, ["secrets"], `Secret reference ${reference} is not declared`);
-    const used = new Set(references);
-    scenario.secrets.forEach(({ secret_id: id }, index) => {
-        if (!used.has(id))
-            addIssue(context, ["secrets", index, "secret_id"], `Secret declaration ${id} is unused`);
-    });
-};
-const validateRedactionCoverage = (scenario, context) => {
-    const redactedQueries = new Set(scenario.redaction.query_parameter_names);
-    const destinations = [scenario.start_url];
-    for (const action of scenario.actions)
-        if (action.action === "goto")
-            destinations.push(action.destination);
-    for (const cookie of scenario.storage.cookies)
-        destinations.push(cookie.destination);
-    if (scenario.request_replay.mode === "exact")
-        for (const route of scenario.request_replay.routes) {
-            destinations.push(route.request);
-            if (route.response.kind === "redirect")
-                destinations.push(route.response.destination);
-        }
-    for (const destination of destinations)
-        for (const query of destination.query)
-            if (query.value.source === "secret" &&
-                !redactedQueries.has(query.name.toLowerCase()))
-                addIssue(context, ["redaction", "query_parameter_names"], `Secret query parameter ${query.name} must be declared for redaction`);
 };
 const validateBrowserScenario = (scenario, context) => {
-    const allowedOrigins = new Set(scenario.allowed_origins);
-    assertAllowedDestination(scenario.start_url, allowedOrigins, ["start_url"], context);
     assertUnique(scenario.actions.map(({ step_id: id }) => id), ["actions"], "Action step IDs", context);
     assertUnique(scenario.secrets.map(({ secret_id: id }) => id), ["secrets"], "Secret IDs", context);
     assertUnique(scenario.secrets.map(({ environment_variable: name }) => name), ["secrets"], "Secret environment variables", context);
     const references = scenario.actions.flatMap(actionSecretReferences);
-    for (const [index, action] of scenario.actions.entries())
-        if (action.action === "goto")
-            assertAllowedDestination(action.destination, allowedOrigins, ["actions", index, "destination"], context);
     references.push(...destinationSecretReferences(scenario.start_url));
-    references.push(...validateStorage(scenario, allowedOrigins, context));
-    references.push(...validateRequestReplay(scenario, allowedOrigins, context));
+    references.push(...validateStorage(scenario));
     validateSecretReferences(scenario, references, context);
-    validateRedactionCoverage(scenario, context);
 };
 /** Strict provider-neutral contract for one controlled browser scenario. */
 export const browserScenarioSchema = browserScenarioInputSchema.superRefine(validateBrowserScenario);

package/dist/domain/browserScenarioCapture.js

@@ -13,7 +13,6 @@ export const browserScenarioCaptureSchema = z
     }),
     scenario: z.strictObject({
         start_origin: z.string().min(1),
-        allowed_origins: z.array(z.string().min(1)).min(1),
         action_count: z.number().int().min(1),
         secret_references: z.array(z.string().min(1)),
     }),

package/dist/domain/browserScenarioCaptureValues.js

@@ -1,8 +1,9 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
+import { emptyArraySchema } from "./emptyArraySchema.js";
 import { sanitizedBrowserUrlSchema } from "./browserObservation.js";
 import { webScreenshotArtifactSchema } from "./webScreenshot.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
 const textArtifactSchema = z
     .strictObject({
     sha256: digestSchema,
@@ -199,14 +200,14 @@ export const browserScenarioCompletenessSchema = z.discriminatedUnion("status",
     z.strictObject({
         status: z.literal("complete"),
         equality_eligible: z.literal(true),
-        missing_sections: z.tuple([]),
-        truncated_sections: z.tuple([]),
+        missing_sections: emptyArraySchema,
+        truncated_sections: emptyArraySchema,
     }),
     z.strictObject({
         status: z.literal("incomplete"),
         equality_eligible: z.literal(false),
         missing_sections: z.array(completenessSectionSchema).min(1),
-        truncated_sections: z.tuple([]),
+        truncated_sections: emptyArraySchema,
     }),
     z.strictObject({
         status: z.literal("truncated"),

package/dist/domain/browserScenarioDiff.js

@@ -153,9 +153,7 @@ const missingFailures = (side, stepIds) => stepIds.map((stepId) => ({
 }));
 const captureContextsMatch = (before, after) => before.browser.product === after.browser.product &&
     before.browser.version === after.browser.version &&
-    before.scenario.start_origin === after.scenario.start_origin &&
-    digestCanonicalJson([...before.scenario.allowed_origins].sort()) ===
-        digestCanonicalJson([...after.scenario.allowed_origins].sort());
+    before.scenario.start_origin === after.scenario.start_origin;
 const compareStepArtifacts = (input) => {
     const common = {
         beforeStep: input.beforeStep,