mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
* perf(tests): give MCP test clients the shared lazy schema validation The MCP SDK client compiles every listed tool's output schema on its first tool call. With the SDK's default Ajv options, REA's catalog costs gigabytes of allocation per client (inspect_analysis_view alone: 1.7 s and ~500 MiB retained), so native MCP files peaked at 1-2 GiB per worker. tests/fixtures/mcpSchemaValidation already owns lazy, reference-preserving validation. Route the native MCP, process-boundary and shared harness clients through it, share compiled validators across clients in a worker (bounded LRU keyed by schema text), and add a counted architecture guard so default-validation test clients cannot spread; the remaining copies are the baseline. * fix(guards): read call arguments past parentheses inside string literals * perf(tests): give MCP boundary test clients the shared schema validation (#11022) * perf(tests): give MCP boundary test clients the shared schema validation * perf(tests): give the remaining MCP test clients the shared schema validation (#11025) * fix(guards): read an MCP client's validator option from parsed code The default-validation counter searched each new Client(...) call's text for jsonSchemaValidator, so an inline comment, a string literal or a client name naming the option hid a default client. Parse the source with @babel/parser and count NewExpressions of Client whose object-literal arguments have no jsonSchemaValidator property; a source that does not parse counts every textual call. The guard reads raw test sources, and the generated-child-script allowlist entry, which no longer counts as a call, is removed. * fix(guards): read an MCP client's options only from a whole object-literal argument The default-validation counter skipped files without the text 'new Client(', so a comment between the tokens hid a client, and it took any depth-two key as an option, so 'enabled ? { jsonSchemaValidator } : {}' passed while its false branch uses the SDK default. The skip now only requires the name Client, and the validator counts only when it is a key of an object literal that is a whole argument; anything else counts as the default.
946 lines
33 KiB
TypeScript
946 lines
33 KiB
TypeScript
import { fileSubjectTarget } from "../fixtures/evidenceSubject.js";
|
|
import { unknownTarget } from "../../src/domain/targetIdentity.js";
|
|
import { stat, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
|
|
import { InMemoryTransport, Client } from "@modelcontextprotocol/client";
|
|
import { afterEach, describe, expect, it, onTestFinished, vi } from "vitest";
|
|
import { z } from "zod";
|
|
|
|
import { ARTIFACT_COMPARISON_EXAMPLE } from "../../src/contracts/artifactComparisonExample.js";
|
|
import { FUNCTION_COMPARISON_EXAMPLE } from "../../src/contracts/functionComparisonExample.js";
|
|
import { completeReconstructionCoverageData } from "../../src/domain/reconstructionCoverage.fixture.js";
|
|
import { reconstructionClosureResultSchema } from "../../src/domain/reconstructionCoverage.js";
|
|
import {
|
|
createEvidence,
|
|
evidenceSubjectInput,
|
|
} from "../../src/domain/evidence.js";
|
|
import { RetainedRegularFileCleanupFailure } from "../../src/process/RegularFileRead.js";
|
|
import { OwnedFileHandle } from "../../src/filesystem/OwnedFileHandle.js";
|
|
import { primaryAnalysisError } from "../../src/domain/analysisErrorBase.js";
|
|
import { functionComparisonResultSchema } from "../../src/domain/functionComparisonSchemas.js";
|
|
import { createServer } from "../../src/server/createServer.js";
|
|
import { createTestBinarySession } from "../fixtures/binarySession.js";
|
|
import { parseMcpToolError } from "../fixtures/mcpToolError.js";
|
|
|
|
import {
|
|
MANAGED_APPLICATION_GRAPH_EXAMPLE,
|
|
MANAGED_MEMBER_COMPARISON_EXAMPLE,
|
|
MANAGED_NATIVE_VERIFICATION_EXAMPLE,
|
|
MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE,
|
|
} from "../../src/contracts/managed/managedWorkflowExamples.js";
|
|
import { managedApplicationGraphResultSchema } from "../../src/domain/managed/managedApplicationGraph.js";
|
|
import { managedMemberComparisonResultSchema } from "../../src/domain/managed/managedMemberComparison.js";
|
|
import { managedNativeVerificationResultSchema } from "../../src/domain/managed/managedNativeVerificationSchemas.js";
|
|
import { managedReconstructionImportResultSchema } from "../../src/domain/managed/managedReconstruction.js";
|
|
|
|
import { captureProcessScenarioFile } from "../../src/application/process/ProcessCli.js";
|
|
import { managedComparisonCommand } from "../fixtures/managedComparisonCommand.js";
|
|
import { buildManagedPeFixture } from "../../src/dotnet/ManagedPe.fixture.js";
|
|
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
|
|
import { wasmArtifactFixture } from "../fixtures/wasm/artifact.js";
|
|
import { ProcessCaptureError } from "../../src/process/capture/ProcessCaptureError.js";
|
|
|
|
import { reconstructionObligationLedgerSchema } from "../../src/domain/reconstructionObligationLedgerSchemas.js";
|
|
import {
|
|
request as ledgerRequest,
|
|
processEvidence,
|
|
} from "../../src/application/ReconstructionObligationLedger.fixture.js";
|
|
import { processCaptureSchema } from "../../src/domain/process/processCapture.js";
|
|
import {
|
|
JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
|
|
JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE,
|
|
} from "../../src/contracts/javascript/javascriptRuntimeReconciliationExample.js";
|
|
import { javascriptApplicationAnalysisResultSchema } from "../../src/domain/javascript/javascriptApplicationAnalysis.js";
|
|
import { javaScriptSemanticQueryResultSchema } from "../../src/domain/javascript/javascriptSemanticQuerySchemas.js";
|
|
import {
|
|
JAVASCRIPT_FEATURE_TRACE_EXAMPLE,
|
|
JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE,
|
|
SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE,
|
|
} from "../../src/contracts/javascript/javascriptApplicationWorkflowExamples.js";
|
|
import { JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE } from "../../src/contracts/javascript/javascriptExportShapeComparisonExample.js";
|
|
import { applicationFeatureTraceResultSchema } from "../../src/domain/javascript/javascriptFeatureTraceSchemas.js";
|
|
import { ownedApplicationVersionComparisonResultSchema } from "../../src/domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
|
|
import { javaScriptExportShapeComparisonResultSchema } from "../../src/domain/javascript/javascriptExportShapeComparisonSchemas.js";
|
|
import { sourceToBundleComparisonResultSchema } from "../../src/domain/javascript/sourceToBundleComparisonSchemas.js";
|
|
import { javascriptRuntimeReconciliationResultSchema } from "../../src/domain/javascript/javascriptRuntimeReconciliationSchemas.js";
|
|
import { browserCompletenessSchema } from "../../src/domain/browserCompleteness.js";
|
|
import { createElectronActiveEvidence } from "../../src/application/javascript/ElectronActiveEvidence.js";
|
|
import { electronActiveObservationInputSchema } from "../../src/domain/javascript/electronActiveObservation.js";
|
|
import { createElectronActiveObservationFixtureResult } from "../../src/domain/javascript/electronActiveObservation.fixture.js";
|
|
|
|
import { nativeFunctionMatchingSchema } from "../../src/domain/native/functionMatching.js";
|
|
import { FunctionByteCoverage } from "../../src/domain/native/functionByteCoverage.js";
|
|
import {
|
|
nativeMatchingInventory,
|
|
nativeMatchingDetails,
|
|
} from "../fixtures/nativeFunctionMatching.js";
|
|
import { createMcpSchemaValidation } from "../fixtures/mcpSchemaValidation.js";
|
|
|
|
/** Unexpected implementation failures retain the SDK text surface, without a typed caller error. */
|
|
const expectUnexpectedToolFailure = (
|
|
response: Awaited<ReturnType<Client["callTool"]>>,
|
|
failure: Error,
|
|
): void => {
|
|
expect(response).toMatchObject({
|
|
isError: true,
|
|
content: [{ type: "text", text: failure.message }],
|
|
});
|
|
expect(response.structuredContent).toBeUndefined();
|
|
};
|
|
|
|
const unexpectedResultFailures = [
|
|
["TypeError", () => new TypeError("injected result parser TypeError")],
|
|
["Error", () => new Error("injected result parser Error")],
|
|
[
|
|
"ZodError",
|
|
() => {
|
|
const result = z.string().safeParse(1);
|
|
if (result.success) throw new Error("Expected an invalid string parse");
|
|
return result.error;
|
|
},
|
|
],
|
|
] as const;
|
|
|
|
describe.each([
|
|
{
|
|
name: "trace_application_feature",
|
|
input: JAVASCRIPT_FEATURE_TRACE_EXAMPLE,
|
|
result: applicationFeatureTraceResultSchema,
|
|
},
|
|
{
|
|
name: "compare_application_versions",
|
|
input: JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE,
|
|
result: ownedApplicationVersionComparisonResultSchema,
|
|
},
|
|
{
|
|
name: "compare_javascript_export_shapes",
|
|
input: JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE,
|
|
result: javaScriptExportShapeComparisonResultSchema,
|
|
},
|
|
{
|
|
name: "compare_source_to_bundle",
|
|
input: SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE,
|
|
result: sourceToBundleComparisonResultSchema,
|
|
},
|
|
])("$name output failures through the public SDK", (workflow) => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s without recording sources or derived Evidence",
|
|
async (_kind, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const failure = createFailure();
|
|
vi.spyOn(workflow.result, "parse").mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: workflow.name,
|
|
arguments: workflow.input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
expect(session.exportEvidenceBundle().unknowns).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
const invalidFunctionOperationEvidence = () => {
|
|
const left = FUNCTION_COMPARISON_EXAMPLE.left;
|
|
return createEvidence(
|
|
{
|
|
...fileSubjectTarget(left.subject),
|
|
path: "/tmp/wrong-function-operation",
|
|
},
|
|
left.provider,
|
|
{
|
|
predicateType: left.predicate_type,
|
|
operation: "inspect_analysis_view",
|
|
parameters: left.parameters,
|
|
result: left.normalized_result,
|
|
confidence: left.confidence,
|
|
authority: left.authority,
|
|
...(left.relationship_coverage === null
|
|
? {}
|
|
: { relationshipCoverage: left.relationship_coverage }),
|
|
},
|
|
);
|
|
};
|
|
|
|
const malformedFunctionResultEvidence = () => {
|
|
const left = FUNCTION_COMPARISON_EXAMPLE.left;
|
|
return createEvidence(
|
|
{
|
|
...fileSubjectTarget(left.subject),
|
|
path: "/tmp/malformed-function-result",
|
|
},
|
|
left.provider,
|
|
{
|
|
predicateType: left.predicate_type,
|
|
operation: "analyze_function",
|
|
parameters: left.parameters,
|
|
result: { malformed: true },
|
|
confidence: left.confidence,
|
|
authority: left.authority,
|
|
...(left.relationship_coverage === null
|
|
? {}
|
|
: { relationshipCoverage: left.relationship_coverage }),
|
|
},
|
|
);
|
|
};
|
|
|
|
const withSdk = async <Value>(
|
|
run: (input: {
|
|
readonly client: Client;
|
|
readonly session: ReturnType<typeof createTestBinarySession>;
|
|
}) => Promise<Value>,
|
|
): Promise<Value> => {
|
|
const session = createTestBinarySession(() => {
|
|
throw new Error(
|
|
"These deterministic Evidence tools must not launch a provider",
|
|
);
|
|
});
|
|
const server = createServer({ kind: "session", session });
|
|
const client = new Client(
|
|
{
|
|
name: "derived-operation-failures",
|
|
version: "1",
|
|
},
|
|
{ jsonSchemaValidator: createMcpSchemaValidation() },
|
|
);
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
return await run({ client, session });
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close(), session.close()]);
|
|
}
|
|
};
|
|
|
|
const activeRuntimeFixture = () => {
|
|
const root = join(process.cwd(), "active-runtime-fixture");
|
|
const applicationPath = join(root, "main.js");
|
|
const result = createElectronActiveObservationFixtureResult(applicationPath);
|
|
const input = {
|
|
...electronActiveObservationInputSchema.parse({
|
|
executable_path: process.execPath,
|
|
application_path: applicationPath,
|
|
application_root: root,
|
|
}),
|
|
application_root: root,
|
|
};
|
|
const evidence = createElectronActiveEvidence(
|
|
input,
|
|
result,
|
|
{
|
|
id: "rea-playwright-electron-active",
|
|
name: "REA Playwright active Electron observation provider",
|
|
version: "1",
|
|
},
|
|
input,
|
|
);
|
|
return { evidence, result };
|
|
};
|
|
|
|
describe("runtime reconciliation failure ownership through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from generated reconciliation output",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const failure = createFailure();
|
|
vi.spyOn(
|
|
javascriptRuntimeReconciliationResultSchema,
|
|
"parse",
|
|
).mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "reconcile_javascript_runtime",
|
|
arguments: JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle()).toMatchObject({
|
|
records: [],
|
|
unknowns: [],
|
|
});
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s while interpreting an authenticated active capture",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const { evidence: runtime } = activeRuntimeFixture();
|
|
const failure = createFailure();
|
|
vi.spyOn(browserCompletenessSchema, "parse").mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "reconcile_javascript_runtime",
|
|
arguments: {
|
|
static_layers:
|
|
JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers,
|
|
runtime_observations: [runtime],
|
|
},
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle()).toMatchObject({
|
|
records: [],
|
|
unknowns: [],
|
|
});
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{
|
|
field: "payload",
|
|
path: ["normalized_result", "application", "application_path"],
|
|
reason: "invalid_type",
|
|
},
|
|
{
|
|
field: "parameters",
|
|
path: ["parameters", "resolved_paths", "application_root"],
|
|
reason: "invalid_type",
|
|
},
|
|
{
|
|
field: "scope",
|
|
path: ["normalized_result", "application", "application_path"],
|
|
reason: "invalid_value",
|
|
},
|
|
])(
|
|
"keeps an invalid active $field at its caller path",
|
|
async ({ field, path, reason }) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const { evidence, result } = activeRuntimeFixture();
|
|
const runtime = createEvidence(
|
|
evidenceSubjectInput(evidence.subject),
|
|
evidence.provider,
|
|
{
|
|
operation: evidence.operation,
|
|
predicateType: evidence.predicate_type,
|
|
authority: evidence.authority,
|
|
confidence: evidence.confidence,
|
|
parameters:
|
|
field === "parameters"
|
|
? {
|
|
...evidence.parameters,
|
|
resolved_paths: {
|
|
...(evidence.parameters.resolved_paths as object),
|
|
application_root: 3,
|
|
},
|
|
}
|
|
: evidence.parameters,
|
|
result:
|
|
field === "parameters"
|
|
? result
|
|
: {
|
|
...result,
|
|
application: {
|
|
...result.application,
|
|
application_path:
|
|
field === "payload"
|
|
? 3
|
|
: join(
|
|
process.cwd(),
|
|
"another-application",
|
|
"main.js",
|
|
),
|
|
},
|
|
},
|
|
},
|
|
);
|
|
const response = await client.callTool({
|
|
name: "reconcile_javascript_runtime",
|
|
arguments: {
|
|
static_layers:
|
|
JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE.static_layers,
|
|
runtime_observations: [runtime],
|
|
},
|
|
});
|
|
expect(response.isError).toBe(true);
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
operation: "reconcile_javascript_runtime",
|
|
issues: [{ path: ["runtime_observations", 0, ...path], reason }],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle()).toMatchObject({
|
|
records: [],
|
|
unknowns: [],
|
|
});
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("derived operation failures through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it("keeps a wrong function operation as a caller constraint at left", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const response = await client.callTool({
|
|
name: "compare_functions",
|
|
arguments: {
|
|
left: invalidFunctionOperationEvidence(),
|
|
right: FUNCTION_COMPARISON_EXAMPLE.right,
|
|
},
|
|
});
|
|
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [expect.objectContaining({ path: ["left"] })],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it("keeps malformed analyze_function payloads as Evidence integrity failures", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const response = await client.callTool({
|
|
name: "compare_functions",
|
|
arguments: {
|
|
left: malformedFunctionResultEvidence(),
|
|
right: FUNCTION_COMPARISON_EXAMPLE.right,
|
|
},
|
|
});
|
|
|
|
expect(parseMcpToolError(response).error.code).toBe(
|
|
"evidence_integrity_mismatch",
|
|
);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it("classifies a duplicated call-path function at its second selection", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const source = FUNCTION_COMPARISON_EXAMPLE.left;
|
|
expect(session.recordEvidence(source).ok).toBe(true);
|
|
const before = session.exportEvidenceBundle();
|
|
const response = await client.callTool({
|
|
name: "build_call_path",
|
|
arguments: {
|
|
functions: [source, source],
|
|
start: { address: "0x1000" },
|
|
goal: { address: "0x1001" },
|
|
},
|
|
});
|
|
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [expect.objectContaining({ path: ["functions", 1] })],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle()).toEqual(before);
|
|
});
|
|
});
|
|
|
|
it("classifies a non-inventory artifact carrier at left", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const response = await client.callTool({
|
|
name: "compare_artifacts",
|
|
arguments: {
|
|
left: FUNCTION_COMPARISON_EXAMPLE.left,
|
|
right: ARTIFACT_COMPARISON_EXAMPLE.right,
|
|
},
|
|
});
|
|
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [expect.objectContaining({ path: ["left"] })],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from result validation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const failure = createFailure();
|
|
vi.spyOn(functionComparisonResultSchema, "parse").mockImplementation(
|
|
() => {
|
|
throw failure;
|
|
},
|
|
);
|
|
const response = await client.callTool({
|
|
name: "compare_functions",
|
|
arguments: {
|
|
left: FUNCTION_COMPARISON_EXAMPLE.left,
|
|
right: FUNCTION_COMPARISON_EXAMPLE.right,
|
|
},
|
|
});
|
|
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from coverage result validation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const coverage = completeReconstructionCoverageData();
|
|
const failure = createFailure();
|
|
vi.spyOn(reconstructionClosureResultSchema, "parse").mockImplementation(
|
|
() => {
|
|
throw failure;
|
|
},
|
|
);
|
|
const response = await client.callTool({
|
|
name: "evaluate_reconstruction_coverage",
|
|
arguments: { coverage, boundary_id: "replacement.cli" },
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
const managedWorkflows = [
|
|
{
|
|
name: "project_managed_application_graph",
|
|
input: MANAGED_APPLICATION_GRAPH_EXAMPLE,
|
|
result: managedApplicationGraphResultSchema,
|
|
sourceField: "managed_members",
|
|
source: MANAGED_APPLICATION_GRAPH_EXAMPLE.managed_members,
|
|
},
|
|
{
|
|
name: "compare_managed_members",
|
|
input: MANAGED_MEMBER_COMPARISON_EXAMPLE,
|
|
result: managedMemberComparisonResultSchema,
|
|
sourceField: "left",
|
|
source: MANAGED_MEMBER_COMPARISON_EXAMPLE.left,
|
|
},
|
|
{
|
|
name: "verify_managed_native_boundaries",
|
|
input: MANAGED_NATIVE_VERIFICATION_EXAMPLE,
|
|
result: managedNativeVerificationResultSchema,
|
|
sourceField: "managed_boundaries",
|
|
source: MANAGED_NATIVE_VERIFICATION_EXAMPLE.managed_boundaries,
|
|
},
|
|
{
|
|
name: "import_managed_reconstruction",
|
|
input: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE,
|
|
result: managedReconstructionImportResultSchema,
|
|
sourceField: "static_members",
|
|
source: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.static_members,
|
|
},
|
|
] as const;
|
|
|
|
describe.each(managedWorkflows)(
|
|
"$name failure ownership through the public SDK",
|
|
(workflow) => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it("rejects an authentic source with the wrong operation at its selection", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const response = await client.callTool({
|
|
name: workflow.name,
|
|
arguments: {
|
|
...workflow.input,
|
|
[workflow.sourceField]: FUNCTION_COMPARISON_EXAMPLE.left,
|
|
},
|
|
});
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [expect.objectContaining({ path: [workflow.sourceField] })],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it("rejects a malformed authenticated source payload as Evidence integrity", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const source = createEvidence(
|
|
unknownTarget("not-observed"),
|
|
workflow.source.provider,
|
|
{
|
|
operation: workflow.source.operation,
|
|
parameters: {},
|
|
result: { malformed: true },
|
|
},
|
|
);
|
|
const response = await client.callTool({
|
|
name: workflow.name,
|
|
arguments: { ...workflow.input, [workflow.sourceField]: source },
|
|
});
|
|
expect(parseMcpToolError(response).error.code).toBe(
|
|
"evidence_integrity_mismatch",
|
|
);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it("rejects a tampered source before recording any Evidence", async () => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const response = await client.callTool({
|
|
name: workflow.name,
|
|
arguments: {
|
|
...workflow.input,
|
|
[workflow.sourceField]: {
|
|
...workflow.source,
|
|
normalized_result: { tampered: true },
|
|
},
|
|
},
|
|
});
|
|
expect(parseMcpToolError(response).error.code).toBe(
|
|
"evidence_integrity_mismatch",
|
|
);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
});
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from its generated output",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const failure = createFailure();
|
|
vi.spyOn(workflow.result, "parse").mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: workflow.name,
|
|
arguments: workflow.input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
},
|
|
);
|
|
|
|
describe("managed comparison output failure with completed source reads", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it("retains both sources and the output failure cause after reading real artifacts", async () => {
|
|
const root = await createTestTempDirectory("rea-managed-output-failure-");
|
|
const leftPath = join(root, "left.dll");
|
|
const rightPath = join(root, "right.dll");
|
|
await writeFile(leftPath, buildManagedPeFixture());
|
|
await writeFile(
|
|
rightPath,
|
|
buildManagedPeFixture({ methodName: "Changed" }),
|
|
);
|
|
const parsed = z.string().safeParse(1);
|
|
if (parsed.success) throw new Error("Expected invalid output");
|
|
const failure = parsed.error;
|
|
vi.spyOn(managedMemberComparisonResultSchema, "parse").mockImplementation(
|
|
() => {
|
|
throw failure;
|
|
},
|
|
);
|
|
|
|
expect(await managedComparisonCommand()(leftPath, rightPath)).toMatchObject(
|
|
{
|
|
code: "unreadable_output",
|
|
details: {
|
|
argument_observations: [
|
|
{
|
|
argument: "left",
|
|
observation: {
|
|
operation: "inspect_managed_members",
|
|
subject: { local_path: leftPath },
|
|
normalized_result: {
|
|
methods: [expect.objectContaining({ token: "0x06000001" })],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
argument: "right",
|
|
observation: {
|
|
operation: "inspect_managed_members",
|
|
subject: { local_path: rightPath },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("ledger generation failure ownership through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from generated ledger validation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const input = ledgerRequest([processEvidence()]);
|
|
const failure = createFailure();
|
|
vi.spyOn(
|
|
reconstructionObligationLedgerSchema,
|
|
"parse",
|
|
).mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "build_reconstruction_obligation_ledger",
|
|
arguments: input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s while deriving process candidates",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const input = ledgerRequest([processEvidence()]);
|
|
const failure = createFailure();
|
|
vi.spyOn(processCaptureSchema, "safeParse").mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "build_reconstruction_obligation_ledger",
|
|
arguments: input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("process capture CLI cleanup failure projection", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it("preserves sanitized unknown-process IDs and reasons through the capture CLI boundary", async () => {
|
|
const root = await createTestTempDirectory("rea-process-cli-cleanup-");
|
|
const scenario = join(root, "scenario.json");
|
|
await writeFile(
|
|
scenario,
|
|
JSON.stringify({ executable: process.execPath, arguments: [] }),
|
|
);
|
|
const reason =
|
|
"process ownership token could not be read for 1 live process(es): environment_unavailable=1; live candidates 900=environment_unavailable";
|
|
const failure = new ProcessCaptureError("cleanup incomplete", {
|
|
reason: "cleanup_incomplete",
|
|
cleanup: { reason, resources: ["owned_process_group"] },
|
|
cleanupReport: {
|
|
owned_process_group: {
|
|
state: "unverified",
|
|
reason,
|
|
unverified_processes: [
|
|
{ pid: 900, reason: "environment_unavailable" },
|
|
],
|
|
},
|
|
terminal_renderer: { state: "cleaned", reason: null },
|
|
temporary_root: { state: "cleaned", reason: null },
|
|
},
|
|
});
|
|
const processHarness =
|
|
await import("../../src/process/capture/ProcessHarness.js");
|
|
vi.spyOn(processHarness, "captureProcessScenario").mockResolvedValue({
|
|
ok: false,
|
|
error: failure,
|
|
});
|
|
|
|
const projected = await captureProcessScenarioFile(scenario);
|
|
|
|
expect(projected).toMatchObject({
|
|
error: "Process command failed",
|
|
code: "cleanup_incomplete",
|
|
details: {
|
|
cleanup_report: {
|
|
owned_process_group: {
|
|
reason,
|
|
unverified_processes: [
|
|
{ pid: 900, reason: "environment_unavailable" },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("process comparison Evidence authentication failures through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it.each(unexpectedResultFailures.filter(([kind]) => kind !== "ZodError"))(
|
|
"preserves an unexpected %s without retaining Evidence",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const input = {
|
|
left: processEvidence(),
|
|
right: processEvidence(),
|
|
};
|
|
const failure = createFailure();
|
|
const evidenceModule = await import("../../src/domain/evidence.js");
|
|
vi.spyOn(evidenceModule, "parseEvidence").mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "compare_process_captures",
|
|
arguments: input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
expect(session.exportEvidenceBundle().unknowns).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("semantic query output failures through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from generated query validation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const application = JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE;
|
|
const analysis = javascriptApplicationAnalysisResultSchema.parse(
|
|
application.normalized_result,
|
|
);
|
|
const node = analysis.semantic_graph.nodes[0];
|
|
if (node === undefined)
|
|
throw new Error("Expected a semantic fixture node");
|
|
const failure = createFailure();
|
|
vi.spyOn(
|
|
javaScriptSemanticQueryResultSchema,
|
|
"parse",
|
|
).mockImplementation(() => {
|
|
throw failure;
|
|
});
|
|
const response = await client.callTool({
|
|
name: "trace_javascript_semantics",
|
|
arguments: {
|
|
application,
|
|
query: {
|
|
seed: { kind: "semantic-node", node_id: node.node_id },
|
|
direction: "backward-provenance",
|
|
},
|
|
},
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("native matching failure ownership through the public SDK", () => {
|
|
afterEach(() => vi.restoreAllMocks());
|
|
|
|
const matchingInput = () => ({
|
|
left: nativeMatchingInventory("1", [{ address: "0x10", value: "main" }]),
|
|
right: nativeMatchingInventory("2", [{ address: "0x20", value: "main" }]),
|
|
left_observations: nativeMatchingDetails("1", "0x10", "c3"),
|
|
right_observations: nativeMatchingDetails("2", "0x20", "c3"),
|
|
detail: "complete",
|
|
});
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from native matching result validation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const input = matchingInput();
|
|
const failure = createFailure();
|
|
vi.spyOn(nativeFunctionMatchingSchema, "parse").mockImplementation(
|
|
() => {
|
|
throw failure;
|
|
},
|
|
);
|
|
const response = await client.callTool({
|
|
name: "match_native_functions",
|
|
arguments: input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each(unexpectedResultFailures)(
|
|
"preserves an unexpected %s from native byte fingerprint derivation",
|
|
async (_label, createFailure) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const input = matchingInput();
|
|
const failure = createFailure();
|
|
vi.spyOn(
|
|
FunctionByteCoverage.prototype,
|
|
"fingerprint",
|
|
).mockRejectedValue(failure);
|
|
const response = await client.callTool({
|
|
name: "match_native_functions",
|
|
arguments: input,
|
|
});
|
|
expectUnexpectedToolFailure(response, failure);
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("compare_wasm_interfaces Evidence attribution", () => {
|
|
const inspection = (selectedPath?: string) => {
|
|
const report = wasmArtifactFixture();
|
|
return createEvidence(
|
|
{
|
|
path: report.artifact.path,
|
|
sha256: report.artifact.sha256,
|
|
format: "file",
|
|
},
|
|
{ id: "typed-fixture", name: "Typed fixture", version: "1" },
|
|
{
|
|
operation: "inspect_wasm_artifact",
|
|
parameters: { path: selectedPath ?? report.artifact.path },
|
|
result: report,
|
|
confidence: "observed",
|
|
},
|
|
);
|
|
};
|
|
|
|
it.each(["left", "right"] as const)(
|
|
"names the %s argument whose authentic Evidence selects another artifact",
|
|
async (side) => {
|
|
await withSdk(async ({ client, session }) => {
|
|
const rejected = inspection("/artifacts/other.wasm");
|
|
const response = await client.callTool({
|
|
name: "compare_wasm_interfaces",
|
|
arguments: {
|
|
left: side === "left" ? rejected : inspection(),
|
|
right: side === "right" ? rejected : inspection(),
|
|
scope: "both",
|
|
},
|
|
});
|
|
|
|
expect(parseMcpToolError(response).error).toMatchObject({
|
|
code: "invalid_request",
|
|
details: {
|
|
issues: [
|
|
expect.objectContaining({
|
|
path: [side],
|
|
reason: "invalid_value",
|
|
}),
|
|
],
|
|
},
|
|
});
|
|
expect(session.exportEvidenceBundle().records).toEqual([]);
|
|
});
|
|
},
|
|
);
|
|
});
|