rea-agents 6.3.0 → 6.5.0

package/dist/application/native/NativeValueTrace.js

@@ -4,6 +4,8 @@ import { nativeValueTraceInputSchema, nativeValueTraceSchema, } from "../../doma
 import { createEvidence } from "../../domain/evidence.js";
 import { AnalysisCancelledError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { err, ok } from "../../domain/result.js";
+import { jsonParts } from "../../domain/jsonSerialization.js";
+const NODE_PAYLOAD_BYTES = 8 * 1024 * 1024;
 /** Compose bounded high-p-code def-use graphs across exactly referenced call destinations. */
 export const traceNativeValues = async (analysis, parameters, signal) => {
     const input = nativeValueTraceInputSchema.parse(parameters);
@@ -13,17 +15,44 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
     const unknowns = [];
     const callBindings = [];
     const pending = [{ procedure: input.procedure, depth: 0 }];
+    const attempted = new Set();
     const visited = new Set();
     let targetSha256;
     let truncated = false;
     let decompilations = 0;
     let callSites = 0;
     let bytes = 0;
+    let nodeBudgetReached = false;
+    const retainNode = (value) => {
+        if (nodeBudgetReached)
+            return false;
+        if (nodes.length >= input.max_nodes) {
+            truncated = true;
+            nodeBudgetReached = true;
+            return false;
+        }
+        let size = 0;
+        // Reuse bounded JSON encoding to count escapes and UTF-8 expansion
+        // before allocating a complete serialized node that might not fit.
+        for (const part of jsonParts(value)) {
+            size += Buffer.byteLength(part);
+            if (size > NODE_PAYLOAD_BYTES - bytes) {
+                truncated = true;
+                nodeBudgetReached = true;
+                return false;
+            }
+        }
+        bytes += size;
+        nodes.push(value);
+        return true;
+    };
     while (pending.length > 0) {
         if (signal?.aborted)
             return err(new AnalysisCancelledError("trace_native_values"));
         const next = pending.shift();
-        if (next === undefined || visited.has(next.procedure))
+        if (next === undefined ||
+            attempted.has(next.procedure) ||
+            visited.has(next.procedure))
             continue;
         if (decompilations >= input.max_functions) {
             truncated = true;
@@ -34,7 +63,13 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             });
             break;
         }
-        const execution = await analysis.execute("analyze_function", { procedure: next.procedure }, signal === undefined ? {} : { signal });
+        // An exact selector is attempted once per trace, even on failure. Only
+        // successful dossiers establish canonical procedure identity in visited.
+        attempted.add(next.procedure);
+        const execution = await analysis.execute("analyze_function", { procedure: next.procedure }, {
+            ...(signal === undefined ? {} : { signal }),
+            ...(next.depth > 0 ? { selectorOrigin: "provider" } : {}),
+        });
         decompilations++;
         if (!execution.ok) {
             if (execution.error._tag === "AnalysisCancelledError")
@@ -95,6 +130,10 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             });
         }
         const ids = new Set();
+        // Keep generated parameter identity independent of which operations fit
+        // the budget, while preserving every provider-supplied operation ID.
+        const operationIds = new Set(flow.operations.map(({ id }) => id));
+        const parameterIds = new Map();
         const qualified = (id) => `${address}/${id}`;
         for (const operation of flow.operations) {
             if (operation.block_membership === "detached" ||
@@ -108,39 +147,37 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
                 kind: "operation",
                 parameter: null,
             };
-            const size = Buffer.byteLength(JSON.stringify(node));
-            if (nodes.length >= input.max_nodes || bytes + size > 8 * 1024 * 1024) {
-                truncated = true;
+            if (!retainNode(node))
                 break;
-            }
-            bytes += size;
             ids.add(operation.id);
-            nodes.push(node);
         }
         for (const parameter of flow.parameters) {
-            if (nodes.length >= input.max_nodes) {
-                truncated = true;
-                break;
-            }
-            nodes.push({
-                id: `${address}/parameter:${parameter.ordinal}`,
+            const parameterId = `parameter:${parameter.ordinal}`;
+            let localId = parameterId;
+            for (let suffix = 1; operationIds.has(localId); suffix++)
+                localId = `${parameterId}#${suffix}`;
+            const id = qualified(localId);
+            if (!retainNode({
+                id,
                 procedure: address,
                 evidence_id: evidenceId,
                 kind: "parameter",
                 operation: null,
                 parameter,
-            });
+            }))
+                break;
+            parameterIds.set(parameter.ordinal, id);
         }
         for (const use of flow.parameter_uses) {
-            if (!ids.has(use.use) ||
-                !nodes.some((node) => node.id === `${address}/parameter:${use.ordinal}`))
+            const source = parameterIds.get(use.ordinal);
+            if (!ids.has(use.use) || source === undefined)
                 continue;
             if (edges.length >= input.max_edges) {
                 truncated = true;
                 break;
             }
             edges.push({
-                source: `${address}/parameter:${use.ordinal}`,
+                source,
                 target: qualified(use.use),
                 input_index: use.input_index,
                 kind: "parameter-use",
@@ -236,15 +273,31 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             }
         }
         if (truncated &&
-            (nodes.length >= input.max_nodes ||
+            (nodeBudgetReached ||
+                nodes.length >= input.max_nodes ||
                 edges.length >= input.max_edges ||
-                bytes >= 8 * 1024 * 1024))
+                bytes >= NODE_PAYLOAD_BYTES))
             break;
     }
     if (targetSha256 === undefined)
         return err(new AnalysisOutputError("trace_native_values", "No seed function could be analyzed"));
+    const parametersByProcedure = new Map();
+    const returnsByProcedure = new Map();
+    for (const node of nodes) {
+        if (node.kind === "parameter") {
+            const parameters = parametersByProcedure.get(node.procedure) ?? [];
+            parameters.push(node);
+            parametersByProcedure.set(node.procedure, parameters);
+        }
+        else if (node.operation?.opcode === "RETURN" &&
+            node.operation.inputs.length > 1) {
+            const returns = returnsByProcedure.get(node.procedure) ?? [];
+            returns.push(node);
+            returnsByProcedure.set(node.procedure, returns);
+        }
+    }
     for (const binding of callBindings) {
-        const parameters = nodes.filter((node) => node.procedure === binding.callee && node.kind === "parameter");
+        const parameters = parametersByProcedure.get(binding.callee) ?? [];
         if (parameters.length === 0)
             unknowns.push({
                 procedure: binding.caller,
@@ -275,9 +328,7 @@ export const traceNativeValues = async (analysis, parameters, signal) => {
             });
         }
         if (binding.output)
-            for (const node of nodes.filter((node) => node.procedure === binding.callee &&
-                node.operation?.opcode === "RETURN" &&
-                node.operation.inputs.length > 1)) {
+            for (const node of returnsByProcedure.get(binding.callee) ?? []) {
                 if (edges.length >= input.max_edges) {
                     truncated = true;
                     break;

package/dist/application/pcap/PcapAnalysisPort.js

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

package/dist/application/pcap/PcapAnalysisService.js

@@ -0,0 +1,24 @@
+import { pcapRequestSchema, } from "../../domain/pcap/pcapAnalysis.js";
+import { AnalysisCancelledError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
+import { createPcapEvidence } from "../../domain/pcap/pcapEvidence.js";
+import { err, ok } from "../../domain/result.js";
+/** Shared CLI/MCP admission, execution, and Evidence composition for pcap. */
+export class PcapAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Run one caller-selected pcap request and retain capture identity inline. */
+    async execute(operation, input, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(operation));
+        const request = pcapRequestSchema.safeParse({ operation, input });
+        if (!request.success)
+            return err(new AnalysisInputError(operation, { cause: request.error }));
+        const executed = await this.provider.execute(request.data, options);
+        if (!executed.ok)
+            return executed;
+        const execution = executed.value;
+        return ok(createPcapEvidence(request.data, execution));
+    }
+}

package/dist/application/process/ProcessCli.js

@@ -1,7 +1,6 @@
-import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { AnalysisInputError } from "../../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
 import { createEvidence, parseEvidence } from "../../domain/evidence.js";
 import { describeValidationFailure } from "../../domain/evidenceBundle.js";
@@ -11,9 +10,13 @@ import { processTraceSpecificationSchema } from "../../domain/process/processTra
 import { processScenarioSchema } from "../../domain/process/processScenario.js";
 import { compareProcessCaptures } from "../../domain/process/processComparison.js";
 import { parseProcessCapture } from "../../domain/process/processCaptureParsing.js";
+import { createProgressReporter } from "../ProgressReporter.js";
 import { captureProcessScenario } from "../../process/capture/ProcessHarness.js";
-import { PROCESS_PROVIDER } from "../../domain/process/processEvidenceProvider.js";
+import { ProcessCaptureResourceScope } from "../../process/capture/ProcessCaptureLifecycle.js";
+import { PROCESS_PROVIDER, isProcessEvidenceProvider, } from "../../domain/process/processEvidenceProvider.js";
 import { createProcessCaptureEvidence } from "./ProcessEvidence.js";
+import { readJsonFile } from "../JsonFiles.js";
+import { RegularFileCleanupFailure } from "../RegularFileRead.js";
 /** Identify the process workflow's typed diagnostic result for CLI exit status. */
 export const isProcessCliFailure = (value) => typeof value === "object" &&
     value !== null &&
@@ -26,27 +29,41 @@ export const isProcessCliFailure = (value) => typeof value === "object" &&
 /** Capture one JSON scenario through the shared process harness and Evidence contract. */
 export const captureProcessScenarioFile = async (path, environment = process.env, signal) => {
     try {
-        const input = await readJson(path);
+        const input = await readJson(path, "capture_process_scenario", signal);
         const parsed = processScenarioSchema.safeParse(input);
         if (!parsed.success)
             throw analysisInputErrorFromIssues("capture_process_scenario", parsed.error.issues, input, { cause: parsed.error });
-        const captured = await captureProcessScenario(parsed.data, signal, process.platform, environment);
+        const progress = createProgressReporter(async (update) => {
+            process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
+        }, { minimumIntervalMs: 100 });
+        const resourceScope = new ProcessCaptureResourceScope();
+        const captured = await captureProcessScenario(parsed.data, signal, process.platform, environment, undefined, undefined, progress, resourceScope);
+        try {
+            await resourceScope.close();
+        }
+        catch (cause) {
+            if (!captured.ok)
+                return cliAnalysisError(captured.error);
+            throw cause;
+        }
         if (!captured.ok)
             return cliAnalysisError(captured.error);
         return createProcessCaptureEvidence(parsed.data, captured.value);
     }
     catch (cause) {
+        if (cause instanceof RegularFileCleanupFailure)
+            throw cause;
         return projectProcessCliError(cause);
     }
 };
 /** Compare two capture Evidence files and emit derived comparison Evidence. */
-export const compareProcessEvidenceFiles = async (leftPath, rightPath, traceSpecPath) => {
+export const compareProcessEvidenceFiles = async (leftPath, rightPath, traceSpecPath, signal) => {
     try {
-        const left = parseCaptureEvidence(await readJson(leftPath));
-        const right = parseCaptureEvidence(await readJson(rightPath));
+        const left = parseCaptureEvidence(await readJson(leftPath, "compare_process_captures", signal), "left");
+        const right = parseCaptureEvidence(await readJson(rightPath, "compare_process_captures", signal), "right");
         const traceSpecification = traceSpecPath === undefined
             ? undefined
-            : parseTraceSpecification(await readJson(traceSpecPath));
+            : parseTraceSpecification(await readJson(traceSpecPath, "compare_process_captures", signal));
         const comparison = traceSpecification === undefined
             ? compareProcessCaptures(left.capture, right.capture)
             : compareProcessCaptures(left.capture, right.capture, {
@@ -73,10 +90,12 @@ export const compareProcessEvidenceFiles = async (leftPath, rightPath, traceSpec
         });
     }
     catch (cause) {
+        if (cause instanceof RegularFileCleanupFailure)
+            throw cause;
         return projectProcessCliError(cause);
     }
 };
-const parseCaptureEvidence = (input) => {
+const parseCaptureEvidence = (input, side) => {
     let evidence;
     try {
         evidence = parseEvidence(input);
@@ -87,11 +106,17 @@ const parseCaptureEvidence = (input) => {
         throw invalidCaptureEvidence(cause);
     }
     if (evidence.operation !== "capture_process_scenario" ||
-        evidence.predicate_type !== "rea.process-capture" ||
-        evidence.provider.id !== PROCESS_PROVIDER.id ||
-        evidence.provider.version !== PROCESS_PROVIDER.version) {
+        evidence.predicate_type !== "rea.process-capture") {
         throw new ProcessCliFailure("invalid_input", "Capture evidence is not from the current process-capture workflow. Create new capture evidence, then try again.");
     }
+    if (!isProcessEvidenceProvider(evidence.provider))
+        throw new AnalysisInputError("compare_process_captures", undefined, [
+            {
+                path: [side, "provider"],
+                reason: "invalid_value",
+                message: `The ${side} Evidence provider ${evidence.provider.id} v${evidence.provider.version} (${evidence.provider.name}) is not the current or supported legacy ${PROCESS_PROVIDER.id} v${PROCESS_PROVIDER.version} process capture provider.`,
+            },
+        ]);
     try {
         return {
             id: evidence.evidence_id,
@@ -114,25 +139,25 @@ const parseTraceSpecification = (input) => {
     })));
 };
 const invalidCaptureEvidence = (cause) => new ProcessCliFailure("invalid_input", `Capture evidence is malformed (${describeValidationFailure(cause)}). Create new capture evidence, then try again.`);
-const readJson = async (path) => {
-    let bytes;
-    try {
-        bytes = await readFile(path);
-    }
-    catch (cause) {
-        throw new ProcessCliFailure("invalid_input", `Process input file could not be read: ${path} (${describeValidationFailure(cause)}). Check the reported filesystem constraint and retry.`);
-    }
-    try {
-        const text = new TextDecoder("utf-8", {
-            fatal: true,
-            ignoreBOM: true,
-        }).decode(bytes);
-        const parsed = JSON.parse(text);
-        return parsed;
-    }
-    catch (cause) {
-        throw new ProcessCliFailure("invalid_input", `Process input file is not valid UTF-8 JSON: ${path} (${describeValidationFailure(cause)}). Repair the file, then try again.`);
-    }
+const readJson = async (path, operation, signal) => {
+    if (signal?.aborted)
+        throw new AnalysisCancelledError(operation);
+    const loaded = await readJsonFile(path, signal).catch((cause) => {
+        if (signal?.aborted === true &&
+            !(cause instanceof RegularFileCleanupFailure))
+            throw new AnalysisCancelledError(operation, { cause });
+        throw cause;
+    });
+    if (signal?.aborted)
+        throw new AnalysisCancelledError(operation);
+    if (loaded.ok)
+        return loaded.value;
+    if (loaded.error._tag !== "EvidenceFileError")
+        throw loaded.error;
+    const detail = describeValidationFailure(loaded.error.cause);
+    throw new ProcessCliFailure("invalid_input", loaded.error.reason === "invalid-json"
+        ? `Process input file is not valid UTF-8 JSON: ${path} (${detail}). Repair the file, then try again.`
+        : `Process input file could not be read: ${path} (${detail}). Check the reported filesystem constraint and retry.`);
 };
 class ProcessCliFailure extends Error {
     category;

package/dist/application/reverse/ReverseEngineeringCommandPort.js

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