rea-agents 1.0.0 → 1.2.0

package/dist/application/ProcessCli.js

@@ -0,0 +1,61 @@
+import { readFile } from "node:fs/promises";
+import { parseConfig } from "../config.js";
+import { createEvidence, parseEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { compareProcessCaptures, LEGACY_PROCESS_CAPTURE_MESSAGE, parseProcessScenario, parseProcessCapture, } from "../domain/processCapture.js";
+import { captureProcessScenario } from "./ProcessHarness.js";
+import { PROCESS_PROVIDER, createProcessCaptureEvidence, } from "./ProcessEvidence.js";
+const MAX_INPUT_BYTES = 64 * 1024 * 1024;
+/** Capture one JSON scenario through the same policy and evidence contract as MCP. */
+export const captureProcessScenarioFile = async (path) => {
+    const scenario = parseProcessScenario(await readJson(path));
+    const config = parseConfig(process.env);
+    if (!config.ok)
+        throw config.error;
+    const captured = await captureProcessScenario(scenario, config.value.processExecutionPolicy);
+    if (!captured.ok)
+        throw captured.error;
+    return createProcessCaptureEvidence(scenario, captured.value);
+};
+/** Compare two capture Evidence files and emit derived comparison Evidence. */
+export const compareProcessEvidenceFiles = async (leftPath, rightPath) => {
+    const left = parseCaptureEvidence(await readJson(leftPath));
+    const right = parseCaptureEvidence(await readJson(rightPath));
+    const comparison = compareProcessCaptures(left.capture, right.capture);
+    return createEvidence(undefined, PROCESS_PROVIDER, {
+        predicateType: "rea.process-comparison/v3",
+        operation: "compare_process_captures",
+        parameters: {
+            left_evidence_id: left.id,
+            right_evidence_id: right.id,
+            left_normalization: left.capture.normalization,
+            right_normalization: right.capture.normalization,
+        },
+        result: jsonValueSchema.parse(comparison),
+        confidence: "derived",
+        authority: "analyst-inference",
+        limitations: comparison.limitations,
+        evidenceLinks: [left.id, right.id],
+    });
+};
+const parseCaptureEvidence = (input) => {
+    const evidence = parseEvidence(input);
+    if (evidence.operation !== "capture_process_scenario" ||
+        evidence.predicate_type !== "rea.process-capture/v4" ||
+        evidence.provider.id !== PROCESS_PROVIDER.id ||
+        evidence.provider.version !== PROCESS_PROVIDER.version) {
+        if (evidence.predicate_type === "rea.process-capture/v3")
+            throw new TypeError(LEGACY_PROCESS_CAPTURE_MESSAGE);
+        throw new TypeError("Expected REA Process Capture v4 Evidence");
+    }
+    return {
+        id: evidence.evidence_id,
+        capture: parseProcessCapture(evidence.normalized_result),
+    };
+};
+const readJson = async (path) => {
+    const bytes = await readFile(path);
+    if (bytes.length > MAX_INPUT_BYTES)
+        throw new TypeError("Process JSON input exceeds byte limit");
+    return JSON.parse(bytes.toString("utf8"));
+};

package/dist/application/ProcessEvidence.js

@@ -0,0 +1,38 @@
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { parseProcessCapture } from "../domain/processCapture.js";
+/** Provider identity for controlled Process Capture v4 evidence. */
+export const PROCESS_PROVIDER = {
+    id: "rea-process",
+    name: "REA deterministic process harness",
+    version: "3",
+};
+/** Project one process scenario into secret-free Evidence parameters. */
+const processEvidenceParameters = (scenario) => ({
+    executable_name: scenario.executable.split("/").at(-1) ?? scenario.executable,
+    argument_count: scenario.arguments.length,
+    event_count: scenario.events.length,
+    filesystem_root_count: scenario.filesystem_roots.length,
+    checkpoint_count: scenario.checkpoints.length,
+    command_shim_count: scenario.command_shims.length,
+    normalization: scenario.normalization,
+});
+/** Create one canonical observed Process Capture v4 Evidence record. */
+export const createProcessCaptureEvidence = (scenario, capture) => {
+    const validatedCapture = parseProcessCapture(capture);
+    return createEvidence(undefined, PROCESS_PROVIDER, {
+        predicateType: "rea.process-capture/v4",
+        operation: "capture_process_scenario",
+        parameters: processEvidenceParameters(scenario),
+        result: jsonValueSchema.parse(validatedCapture),
+        confidence: "observed",
+        authority: "controlled-replay",
+        environment: {
+            id: `${process.platform}-${process.arch}`,
+            platform: process.platform,
+            architecture: process.arch,
+            isolation: "process",
+        },
+        limitations: validatedCapture.limitations,
+    });
+};