rea-agents 1.1.0 → 1.3.0

package/dist/application/ProcessCli.js

@@ -0,0 +1,128 @@
+import { readFile } from "node:fs/promises";
+import { parseConfig } from "../config.js";
+import { AnalysisError, projectAnalysisError } from "../domain/errors.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;
+/** Distinguish a safe process-command failure from successful Evidence. */
+export const isProcessCliErrorOutput = (value) => typeof value === "object" &&
+    value !== null &&
+    "error" in value &&
+    value.error === "Process command failed" &&
+    "category" in value &&
+    typeof value.category === "string" &&
+    "message" in value &&
+    typeof value.message === "string";
+/** Capture one JSON scenario through the same policy and evidence contract as MCP. */
+export const captureProcessScenarioFile = async (path) => {
+    try {
+        const input = await readJson(path);
+        let scenario;
+        try {
+            scenario = parseProcessScenario(input);
+        }
+        catch {
+            throw new ProcessCliFailure("invalid_input", "Process scenario is invalid. Check its required fields and limits, then try again.");
+        }
+        const config = parseConfig(process.env);
+        if (!config.ok)
+            return cliAnalysisError(config.error);
+        const captured = await captureProcessScenario(scenario, config.value.processExecutionPolicy);
+        if (!captured.ok)
+            return cliAnalysisError(captured.error);
+        return createProcessCaptureEvidence(scenario, captured.value);
+    }
+    catch (cause) {
+        return projectProcessCliError(cause);
+    }
+};
+/** Compare two capture Evidence files and emit derived comparison Evidence. */
+export const compareProcessEvidenceFiles = async (leftPath, rightPath) => {
+    try {
+        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],
+        });
+    }
+    catch (cause) {
+        return projectProcessCliError(cause);
+    }
+};
+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 ProcessCliFailure("invalid_input", LEGACY_PROCESS_CAPTURE_MESSAGE);
+        throw new ProcessCliFailure("invalid_input", "Capture evidence is not from the current process-capture workflow. Create new capture evidence, then try again.");
+    }
+    return {
+        id: evidence.evidence_id,
+        capture: parseProcessCapture(evidence.normalized_result),
+    };
+};
+const readJson = async (path) => {
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch {
+        throw new ProcessCliFailure("invalid_input", "Process input file could not be read. Check that the path exists and is readable.");
+    }
+    if (bytes.length > MAX_INPUT_BYTES)
+        throw new ProcessCliFailure("truncated", "Process input file is too large. Reduce it below 64 MiB, then try again.");
+    try {
+        return JSON.parse(bytes.toString("utf8"));
+    }
+    catch {
+        throw new ProcessCliFailure("invalid_input", "Process input file is not valid JSON. Repair the file, then try again.");
+    }
+};
+class ProcessCliFailure extends Error {
+    category;
+    userMessage;
+    constructor(category, userMessage) {
+        super(userMessage);
+        this.category = category;
+        this.userMessage = userMessage;
+    }
+}
+const cliAnalysisError = (error) => ({
+    error: "Process command failed",
+    ...projectAnalysisError(error),
+});
+/** Project any process CLI failure without exposing its cause. */
+export const projectProcessCliError = (cause) => {
+    if (cause instanceof ProcessCliFailure)
+        return {
+            error: "Process command failed",
+            category: cause.category,
+            message: cause.userMessage,
+        };
+    if (cause instanceof AnalysisError)
+        return cliAnalysisError(cause);
+    return {
+        error: "Process command failed",
+        category: "execution_failure",
+        message: "Process command could not complete. Check the input files and run `rea doctor`, then try again.",
+    };
+};

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,
+    });
+};