* feat(go): inspect embedded binary build metadata * fix(go): preserve byte metadata and validate container mappings * fix(go): support moduleless legacy build metadata Recognize optional module string headers in declared zero-filled memory while rejecting ambiguous and unmapped pointers. Preserve the original module-pointer field as the zero-byte source anchor. Classify initial symlink-loop and overlong-path failures as invalid input, with CLI and MCP regressions. * fix(go): reject undersized PE optional headers * fix(native): stabilize ELF memory checks and clean up exec wrappers Use existing parent/group/run-token ownership for caller-selected Python launchers, which can exec through a shell or prlimit. Add cancellation regressions for the valid wrapper and wrong-parent/token cases. Replace the timing-dependent 30,000-section memory workload with a valid 32 MiB padded ELF under a 64 MiB address-space limit. Check the same image successfully through CLI and MCP before requiring a typed memory failure, preserving the production timeout and all error assertions. Validation: npm run check and check:fast passed; 61 focused tests passed including Go CLI/MCP and session snapshots. Real decoder probes with pinned packages passed on Python 3.12.3 and 3.12.14. The full local ELF verifier is blocked by this container's procps/process-ownership boundary; the exact pushed head requires GitHub's real-binary-layout lane. * test: repair Electron fixtures and stabilize catalog startup checks Declare Electron imports in option, preload override, and path-resolution fixtures after upstream began requiring proven API provenance. Retain all option and preload assertions and adjust exact source ranges for the added import line. Use the existing bounded acceptance timeout for the cold catalog lifecycle test instead of a separate 15-second ceiling. This retains the coverage allowance and all catalog, error, and cleanup assertions without retries. Validation: npm run check, final check:fast, formatting and diff checks passed. Source path regression and Go boundary/MCP/service checks passed. All 20 Go CLI cases and both supported-host runtime cases passed on rerun; two macOS-only cases skipped on Linux. A prior contended local run timed out once in a Go CLI diagnostic; that case passed on rerun. Electron process-boundary verification is blocked locally by procps namespace inspection and requires fresh CI. * test(mcp): isolate nested schema references between tool contracts Clear Ajv's non-meta schema registry after each root, including compilation failures. Disabling root registration alone leaves nested IDs available to later tools and can let a dangling reference pass the catalog gate. Add regressions for leakage after successful and failed compilation while retaining shared meta-schema validators. The regression failed before the fix; all 11 schema cases and full npm run check pass. Reviewed independently. * test(ci): align Go effects and source-map verification contracts Audit the Go inspector wording as static metadata inspection. Assert retained source declaration indexes in BOM reconstruction and the compiler-derived nested-map oracle. Keep a 45,000-map admission control below the 32 MiB output budget and the 50,000-map overflow case above it with the expanded representation. Validation: reproduced all four failing assertions, then passed 120 focused tests and the final admission suite. npm run check and real Chrome 154 / esbuild 0.25.10 source-map verification passed, including all four nested-map scenarios and verified process lineage. --------- Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
734 lines
25 KiB
TypeScript
734 lines
25 KiB
TypeScript
import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
|
|
import { McpServer } from "@modelcontextprotocol/server";
|
|
import { Ajv2020 } from "ajv/dist/2020.js";
|
|
import { describe, expect, it } from "vitest";
|
|
import { z } from "zod";
|
|
|
|
import { advertisedInputExamples } from "../../../src/contracts/advertisedInputExamples.js";
|
|
import { TOOL_CONTRACTS } from "../../../src/contracts/toolContracts.js";
|
|
import { emptyArraySchema } from "../../../src/domain/emptyArraySchema.js";
|
|
import { processScenarioSchema } from "../../../src/domain/process/processScenario.js";
|
|
import { GENERATED_MCP_TOOL_CATALOG } from "../../fixtures/mcpToolCatalog.js";
|
|
import { toolRegistrationOptions } from "../../../src/server/toolRegistrationOptions.js";
|
|
|
|
interface ToolSchemas {
|
|
readonly name: string;
|
|
readonly inputSchema: Record<string, unknown>;
|
|
readonly outputSchema?: Record<string, unknown> | undefined;
|
|
readonly annotations?: Record<string, unknown> | undefined;
|
|
}
|
|
|
|
function schemaErrors(tools: readonly ToolSchemas[]): string[] {
|
|
// Reuse Ajv's meta-schema validators, then clear each root's reference
|
|
// namespace, including nested IDs, before validating the next schema.
|
|
const ajv = new Ajv2020({
|
|
strict: false,
|
|
validateFormats: false,
|
|
addUsedSchema: false,
|
|
});
|
|
return tools.flatMap((tool) =>
|
|
["inputSchema", "outputSchema"].flatMap((kind) => {
|
|
const schema =
|
|
kind === "inputSchema" ? tool.inputSchema : tool.outputSchema;
|
|
if (schema === undefined) return [];
|
|
try {
|
|
if (!ajv.validateSchema(schema))
|
|
return [`${tool.name}.${kind}: ${ajv.errorsText(ajv.errors)}`];
|
|
ajv.compile(schema);
|
|
return [];
|
|
} catch (cause: unknown) {
|
|
return [
|
|
`${tool.name}.${kind}: ${cause instanceof Error ? cause.message : String(cause)}`,
|
|
];
|
|
} finally {
|
|
ajv.removeSchema();
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
function expectStrictInputSchemaParity(
|
|
tools: readonly ToolSchemas[],
|
|
ajv: Ajv2020,
|
|
): void {
|
|
const advertised = new Map(tools.map((tool) => [tool.name, tool]));
|
|
const names = [
|
|
"inspect_managed_artifact",
|
|
"inspect_managed_members",
|
|
"inspect_managed_native_boundaries",
|
|
"list_browser_targets",
|
|
"open_binary",
|
|
"close_binary",
|
|
"binary_session",
|
|
"find_changed_behavior",
|
|
"build_call_path",
|
|
"record_unknown",
|
|
"update_unknown",
|
|
];
|
|
for (const name of names) {
|
|
const contract = TOOL_CONTRACTS.find(
|
|
({ name: toolName }) => toolName === name,
|
|
);
|
|
const tool = advertised.get(name);
|
|
const example = contract?.examples[0];
|
|
if (contract === undefined || tool === undefined || example === undefined)
|
|
throw new Error(`${name} did not have an advertised example`);
|
|
const malformed = { ...example.input, __unexpected_root_key__: true };
|
|
expect(contract.inputSchema.safeParse(malformed).success, name).toBe(false);
|
|
expect(ajv.compile(tool.inputSchema)(malformed), name).toBe(false);
|
|
}
|
|
}
|
|
|
|
function expectKnownAuthorityHints(tools: readonly ToolSchemas[]): void {
|
|
const advertised = new Map(tools.map((tool) => [tool.name, tool]));
|
|
const expected = {
|
|
read_bytes: {
|
|
readOnlyHint: false,
|
|
destructiveHint: false,
|
|
idempotentHint: true,
|
|
openWorldHint: false,
|
|
},
|
|
annotate_native_function: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
idempotentHint: true,
|
|
openWorldHint: true,
|
|
},
|
|
unset_bookmark: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
idempotentHint: true,
|
|
openWorldHint: false,
|
|
},
|
|
open_binary: {
|
|
readOnlyHint: false,
|
|
destructiveHint: false,
|
|
idempotentHint: true,
|
|
openWorldHint: true,
|
|
},
|
|
close_binary: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
idempotentHint: false,
|
|
openWorldHint: false,
|
|
},
|
|
export_web_scripts: {
|
|
readOnlyHint: false,
|
|
destructiveHint: false,
|
|
idempotentHint: false,
|
|
openWorldHint: false,
|
|
},
|
|
capture_process_scenario: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
openWorldHint: true,
|
|
},
|
|
observe_native_calls: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
},
|
|
uninstall_adb_package: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
},
|
|
start_adb_app: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
},
|
|
export_evidence_bundle: {
|
|
readOnlyHint: false,
|
|
destructiveHint: true,
|
|
},
|
|
import_evidence_bundle: {
|
|
readOnlyHint: false,
|
|
destructiveHint: false,
|
|
},
|
|
} as const;
|
|
|
|
for (const [name, annotations] of Object.entries(expected))
|
|
expect(advertised.get(name), name).toMatchObject({ annotations });
|
|
}
|
|
|
|
function expectMeaningfulPropertyDescriptions(
|
|
schema: unknown,
|
|
path: string,
|
|
root: unknown = schema,
|
|
active: ReadonlySet<string> = new Set(),
|
|
): void {
|
|
if (!isRecord(schema)) return;
|
|
if (typeof schema.$ref === "string" && !active.has(schema.$ref))
|
|
expectMeaningfulPropertyDescriptions(
|
|
resolveReference(root, schema.$ref),
|
|
`${path}.${schema.$ref}`,
|
|
root,
|
|
new Set([...active, schema.$ref]),
|
|
);
|
|
if (isRecord(schema.properties)) {
|
|
for (const [property, child] of Object.entries(schema.properties)) {
|
|
// Omit a description rather than restate the property name.
|
|
const description = isRecord(child) ? child.description : undefined;
|
|
if (description !== undefined)
|
|
expect(description, `${path}.${property}`).toEqual(
|
|
expect.not.stringMatching(/^(?:Value for .*)?$/u),
|
|
);
|
|
expectMeaningfulPropertyDescriptions(
|
|
child,
|
|
`${path}.${property}`,
|
|
root,
|
|
active,
|
|
);
|
|
}
|
|
}
|
|
|
|
for (const key of ["items", "additionalProperties"])
|
|
if (schema[key] !== undefined)
|
|
expectMeaningfulPropertyDescriptions(schema[key], path, root, active);
|
|
for (const key of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
|
|
const children = schema[key];
|
|
if (Array.isArray(children))
|
|
children.forEach((child: unknown, index: number) =>
|
|
expectMeaningfulPropertyDescriptions(
|
|
child,
|
|
`${path}.${key}[${index}]`,
|
|
root,
|
|
active,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
const isRecord = (value: unknown): value is Record<string, unknown> =>
|
|
typeof value === "object" && value !== null && !Array.isArray(value);
|
|
|
|
function resolveReference(schema: unknown, reference: string): unknown {
|
|
if (reference === "#") return schema;
|
|
if (!reference.startsWith("#/")) return undefined;
|
|
let value = schema;
|
|
for (const token of reference.slice(2).split("/")) {
|
|
const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
|
|
if (
|
|
typeof value !== "object" ||
|
|
value === null ||
|
|
!Object.hasOwn(value, key)
|
|
)
|
|
return undefined;
|
|
value = Reflect.get(value, key);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function recursiveReferences(tools: readonly ToolSchemas[]): string[] {
|
|
return tools.flatMap((tool) =>
|
|
(["inputSchema", "outputSchema"] as const).flatMap((kind) => {
|
|
const schema = tool[kind];
|
|
const found = new Set<string>();
|
|
const visit = (node: unknown, active: readonly string[]): void => {
|
|
if (typeof node !== "object" || node === null) return;
|
|
for (const [key, child] of Object.entries(node)) {
|
|
if (
|
|
[
|
|
"$defs",
|
|
"definitions",
|
|
"examples",
|
|
"default",
|
|
"const",
|
|
"enum",
|
|
].includes(key)
|
|
)
|
|
continue;
|
|
if (key !== "$ref" || typeof child !== "string") visit(child, active);
|
|
else if (active.includes(child)) found.add(child);
|
|
else visit(resolveReference(schema, child), [...active, child]);
|
|
}
|
|
};
|
|
visit(schema, []);
|
|
return [...found].map(
|
|
(reference) => `${tool.name}.${kind}: ${reference}`,
|
|
);
|
|
}),
|
|
);
|
|
}
|
|
|
|
const advertiseAndEnforceProcessEnvironmentKeyConstraint =
|
|
async (): Promise<void> => {
|
|
const contract = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "capture_process_scenario",
|
|
);
|
|
if (contract === undefined)
|
|
throw new Error("Process capture contract was not registered");
|
|
|
|
let handlerCalled = false;
|
|
const server = new McpServer({ name: "process-schema", version: "0" });
|
|
server.registerTool(
|
|
contract.name,
|
|
{
|
|
title: contract.title,
|
|
description: contract.description,
|
|
inputSchema: processScenarioSchema.shape,
|
|
},
|
|
async () => {
|
|
handlerCalled = true;
|
|
return {
|
|
content: [{ type: "text" as const, text: "handler ran" }],
|
|
isError: true,
|
|
};
|
|
},
|
|
);
|
|
const client = new Client({ name: "process-schema", version: "0" });
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const advertised = (await client.listTools()).tools.find(
|
|
({ name }) => name === contract.name,
|
|
);
|
|
if (advertised === undefined)
|
|
throw new Error("Process capture tool was not advertised");
|
|
|
|
const validate = new Ajv2020({
|
|
strict: false,
|
|
validateFormats: false,
|
|
}).compile(advertised.inputSchema);
|
|
const valid = { executable: "node", environment: { APP_MODE: "test" } };
|
|
const reserved = {
|
|
executable: "node",
|
|
environment: { REA_PROCESS_RUN_ID: "caller-value" },
|
|
};
|
|
const reservedWithTrailingNewline = {
|
|
executable: "node",
|
|
environment: { "REA_PROCESS_RUN_ID\n": "caller-value" },
|
|
};
|
|
expect(validate(valid)).toBe(true);
|
|
expect(contract.inputSchema.safeParse(valid).success).toBe(true);
|
|
expect(validate(reserved)).toBe(false);
|
|
expect(contract.inputSchema.safeParse(reserved).success).toBe(false);
|
|
expect(validate(reservedWithTrailingNewline)).toBe(true);
|
|
expect(
|
|
contract.inputSchema.safeParse(reservedWithTrailingNewline).success,
|
|
).toBe(true);
|
|
|
|
const result = await client.callTool({
|
|
name: contract.name,
|
|
arguments: reserved,
|
|
});
|
|
expect(result.isError).toBe(true);
|
|
expect(handlerCalled).toBe(false);
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close()]);
|
|
}
|
|
};
|
|
|
|
describe("MCP JSON Schema validity", () => {
|
|
it("preserves empty-array validation in the advertised representation", () => {
|
|
const schema = z.toJSONSchema(emptyArraySchema);
|
|
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
|
expect(ajv.validateSchema(schema)).toBe(true);
|
|
const validate = ajv.compile(schema);
|
|
expect(validate([])).toBe(true);
|
|
for (const value of [
|
|
[null],
|
|
["candidate"],
|
|
[0],
|
|
[false],
|
|
[{}],
|
|
[[]],
|
|
null,
|
|
{},
|
|
])
|
|
expect(validate(value)).toBe(false);
|
|
});
|
|
|
|
it("advertises valid input and output schemas for every canonical tool", async () => {
|
|
const server = new McpServer({ name: "schema-validation", version: "0" });
|
|
const client = new Client({ name: "schema-validation", version: "0" });
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
for (const contract of TOOL_CONTRACTS)
|
|
server.registerTool(
|
|
contract.name,
|
|
toolRegistrationOptions(contract),
|
|
async () => ({
|
|
content: [],
|
|
}),
|
|
);
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const { tools } = await client.listTools();
|
|
expect(tools.map(({ name }) => name).sort()).toEqual(
|
|
TOOL_CONTRACTS.map(({ name }) => name).sort(),
|
|
);
|
|
expect(schemaErrors(tools)).toEqual([]);
|
|
expect(recursiveReferences(tools)).toEqual([]);
|
|
expectKnownAuthorityHints(tools);
|
|
const byName = new Map(tools.map((tool) => [tool.name, tool]));
|
|
const catalogProjection = tools.map((tool) => ({
|
|
name: tool.name,
|
|
title: tool.title,
|
|
description: tool.description,
|
|
inputSchema: tool.inputSchema,
|
|
outputSchema: tool.outputSchema,
|
|
annotations: tool.annotations,
|
|
}));
|
|
expect(catalogProjection).toEqual(
|
|
GENERATED_MCP_TOOL_CATALOG.map((tool) => ({
|
|
name: tool.name,
|
|
title: tool.title,
|
|
description: tool.description,
|
|
inputSchema: tool.inputSchema,
|
|
outputSchema: tool.outputSchema,
|
|
annotations: tool.annotations,
|
|
})),
|
|
);
|
|
for (const contract of TOOL_CONTRACTS) {
|
|
const tool = byName.get(contract.name);
|
|
expect(tool?.title?.trim(), contract.name).toBeTruthy();
|
|
expect(tool?.description?.trim(), contract.name).toBeTruthy();
|
|
const examples = advertisedInputExamples(contract);
|
|
expect(tool?.inputSchema.examples, contract.name).toEqual(
|
|
examples.length === 0 ? undefined : examples,
|
|
);
|
|
for (const example of contract.examples)
|
|
expect(
|
|
contract.inputSchema.safeParse(example.input).success,
|
|
`${contract.name}: ${example.title}`,
|
|
).toBe(true);
|
|
expectMeaningfulPropertyDescriptions(tool?.inputSchema, contract.name);
|
|
}
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close()]);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("MCP root input schemas", () => {
|
|
it("advertises object roots while enforcing union requirements at runtime", async () => {
|
|
const server = new McpServer({ name: "schema-constraints", version: "0" });
|
|
const client = new Client({ name: "schema-constraints", version: "0" });
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
for (const contract of TOOL_CONTRACTS)
|
|
server.registerTool(
|
|
contract.name,
|
|
toolRegistrationOptions(contract),
|
|
async () => ({ content: [] }),
|
|
);
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const { tools } = await client.listTools();
|
|
const advertised = new Map(tools.map((tool) => [tool.name, tool]));
|
|
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
|
const graphContract = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "project_managed_application_graph",
|
|
);
|
|
const graphTool = advertised.get("project_managed_application_graph");
|
|
if (graphContract === undefined || graphTool === undefined)
|
|
throw new Error("Managed application graph tool was not advertised");
|
|
expect(graphContract.inputSchema.safeParse({}).success).toBe(false);
|
|
expect(graphTool.inputSchema).toMatchObject({ type: "object" });
|
|
expect(ajv.compile(graphTool.inputSchema)({})).toBe(false);
|
|
expect(ajv.compile(graphTool.inputSchema)({ unrelated: true })).toBe(
|
|
false,
|
|
);
|
|
expect(graphTool.inputSchema.description).toContain(
|
|
"Provide a complete input group",
|
|
);
|
|
expect(graphTool.inputSchema.description).not.toContain("exactly one");
|
|
|
|
for (const contract of TOOL_CONTRACTS) {
|
|
const inputSchema = advertised.get(contract.name)!.inputSchema;
|
|
expect(inputSchema.type, contract.name).toBe("object");
|
|
expect(inputSchema.properties, contract.name).toBeDefined();
|
|
// Anthropic tool input schemas reject root combinators.
|
|
for (const combinator of ["anyOf", "oneOf", "allOf"])
|
|
expect(inputSchema, contract.name).not.toHaveProperty(combinator);
|
|
const validate = ajv.compile(inputSchema);
|
|
for (const example of contract.examples)
|
|
expect(
|
|
validate(example.input),
|
|
`${contract.name}: ${example.title}`,
|
|
).toBe(true);
|
|
}
|
|
|
|
expectStrictInputSchemaParity(tools, ajv);
|
|
|
|
const nativeObservation = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "observe_native_ui",
|
|
);
|
|
const nativeScenario = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "capture_native_ui_scenario",
|
|
);
|
|
const nativeObservationTool = advertised.get("observe_native_ui");
|
|
const nativeScenarioTool = advertised.get("capture_native_ui_scenario");
|
|
if (
|
|
nativeObservation === undefined ||
|
|
nativeScenario === undefined ||
|
|
nativeObservationTool === undefined ||
|
|
nativeScenarioTool === undefined
|
|
)
|
|
throw new Error("Native UI tools were not registered");
|
|
const target = { pid: 123, window_id: 456 };
|
|
const scenario = {
|
|
...target,
|
|
steps: [{ kind: "wait", milliseconds: 100 }],
|
|
};
|
|
const observationResult = nativeObservation.inputSchema.safeParse(target);
|
|
const scenarioResult = nativeScenario.inputSchema.safeParse(scenario);
|
|
expect(observationResult.success).toBe(true);
|
|
expect(scenarioResult.success).toBe(true);
|
|
expect(ajv.compile(nativeObservationTool.inputSchema)(target)).toBe(true);
|
|
expect(ajv.compile(nativeScenarioTool.inputSchema)(scenario)).toBe(true);
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close()]);
|
|
}
|
|
});
|
|
});
|
|
|
|
it(
|
|
"advertises and enforces the process-owned environment key constraint",
|
|
advertiseAndEnforceProcessEnvironmentKeyConstraint,
|
|
);
|
|
|
|
const advertiseAndEnforceItemSelectorCollectionConstraints =
|
|
async (): Promise<void> => {
|
|
const contract = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "inspect_analysis_view",
|
|
);
|
|
if (contract === undefined)
|
|
throw new Error("inspect_analysis_view contract was not registered");
|
|
|
|
const server = new McpServer({
|
|
name: "item-selector-schema",
|
|
version: "0",
|
|
});
|
|
server.registerTool(
|
|
contract.name,
|
|
toolRegistrationOptions(contract),
|
|
async () => ({
|
|
content: [],
|
|
}),
|
|
);
|
|
const client = new Client({ name: "item-selector-schema", version: "0" });
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const advertised = (await client.listTools()).tools.find(
|
|
({ name }) => name === contract.name,
|
|
);
|
|
if (advertised === undefined)
|
|
throw new Error("inspect_analysis_view tool was not advertised");
|
|
|
|
const validate = new Ajv2020({
|
|
strict: false,
|
|
validateFormats: false,
|
|
}).compile(advertised.inputSchema);
|
|
const source = {
|
|
kind: "retained-evidence",
|
|
evidence_id: `ev_${"a".repeat(64)}`,
|
|
};
|
|
const itemInput = (collection: string, selector: unknown) => ({
|
|
source,
|
|
view: { kind: "item", collection, selector },
|
|
});
|
|
const nodeId = `jag_node_${"b".repeat(64)}`;
|
|
// Collection-specific selector constraints must survive JSON Schema
|
|
// conversion: the advertised schema rejects exactly what runtime
|
|
// input validation rejects.
|
|
const invalid: ReadonlyArray<readonly [string, unknown]> = [
|
|
["modules", { index: 0 }],
|
|
["modules", { name: "entry" }],
|
|
["sections", { path: "/src/entry.js" }],
|
|
["symbols", { node_id: nodeId }],
|
|
];
|
|
const valid: ReadonlyArray<readonly [string, unknown]> = [
|
|
["modules", { path: "/src/entry.js" }],
|
|
["modules", { node_id: nodeId }],
|
|
["sections", { index: 0 }],
|
|
["sections", { name: ".text" }],
|
|
["symbols", { index: 0 }],
|
|
["symbols", { name: "main" }],
|
|
];
|
|
for (const [collection, selector] of invalid) {
|
|
const input = itemInput(collection, selector);
|
|
const label = `${collection}/${Object.keys(selector as object)[0]}`;
|
|
expect(contract.inputSchema.safeParse(input).success, label).toBe(
|
|
false,
|
|
);
|
|
expect(validate(input), `advertised schema rejects ${label}`).toBe(
|
|
false,
|
|
);
|
|
}
|
|
for (const [collection, selector] of valid) {
|
|
const input = itemInput(collection, selector);
|
|
const label = `${collection}/${Object.keys(selector as object)[0]}`;
|
|
expect(contract.inputSchema.safeParse(input).success, label).toBe(true);
|
|
expect(validate(input), `advertised schema accepts ${label}`).toBe(
|
|
true,
|
|
);
|
|
}
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close()]);
|
|
}
|
|
};
|
|
|
|
it(
|
|
"advertises and enforces the item selector collection constraints",
|
|
advertiseAndEnforceItemSelectorCollectionConstraints,
|
|
);
|
|
|
|
describe("MCP process input JSON Schema", () => {
|
|
it("advertises process strings without weakening terminal input", async () => {
|
|
const server = new McpServer({
|
|
name: "process-schema-validation",
|
|
version: "0",
|
|
});
|
|
const client = new Client({
|
|
name: "process-schema-validation",
|
|
version: "0",
|
|
});
|
|
const [clientTransport, serverTransport] =
|
|
InMemoryTransport.createLinkedPair();
|
|
for (const contract of TOOL_CONTRACTS)
|
|
server.registerTool(
|
|
contract.name,
|
|
toolRegistrationOptions(contract),
|
|
async () => ({ content: [] }),
|
|
);
|
|
try {
|
|
await server.connect(serverTransport);
|
|
await client.connect(clientTransport);
|
|
const processContract = TOOL_CONTRACTS.find(
|
|
({ name }) => name === "capture_process_scenario",
|
|
);
|
|
const processTool = (await client.listTools()).tools.find(
|
|
({ name }) => name === "capture_process_scenario",
|
|
);
|
|
if (processContract === undefined || processTool === undefined)
|
|
throw new Error("Process scenario tool was not advertised");
|
|
const validate = new Ajv2020({
|
|
strict: false,
|
|
validateFormats: false,
|
|
}).compile(processTool.inputSchema);
|
|
const base = { executable: "/usr/bin/true" };
|
|
for (const input of [
|
|
{ ...base, executable: "/usr/bin/true\0" },
|
|
{ ...base, arguments: ["\0"] },
|
|
{ ...base, working_directory: "/tmp\0" },
|
|
{ ...base, environment: { KEY: "value\0" } },
|
|
{ ...base, filesystem_observation_paths: ["/tmp\0"] },
|
|
]) {
|
|
expect(processContract.inputSchema.safeParse(input).success).toBe(
|
|
false,
|
|
);
|
|
expect(validate(input)).toBe(false);
|
|
}
|
|
const terminalInput = {
|
|
...base,
|
|
events: [{ type: "input", at_ms: 0, data: "\0" }],
|
|
};
|
|
expect(processContract.inputSchema.safeParse(terminalInput).success).toBe(
|
|
true,
|
|
);
|
|
expect(validate(terminalInput)).toBe(true);
|
|
} finally {
|
|
await Promise.allSettled([client.close(), server.close()]);
|
|
}
|
|
});
|
|
});
|
|
|
|
it("ships nonrecursive input and output schemas in the generated catalog", () => {
|
|
expect(schemaErrors(GENERATED_MCP_TOOL_CATALOG)).toEqual([]);
|
|
expect(recursiveReferences(GENERATED_MCP_TOOL_CATALOG)).toEqual([]);
|
|
});
|
|
|
|
it("rejects unresolved output-schema references even for uncalled tools", () => {
|
|
const errors = schemaErrors([
|
|
{
|
|
name: "dangling",
|
|
inputSchema: { type: "object" },
|
|
outputSchema: { $ref: "#/$defs/missing" },
|
|
},
|
|
]);
|
|
expect(errors).toHaveLength(1);
|
|
expect(errors[0]).toContain("dangling.outputSchema");
|
|
});
|
|
|
|
it("validates each tool independently when output schema IDs repeat", () => {
|
|
const outputSchema = { $id: "urn:rea:test:shared-output", type: "string" };
|
|
const errors = schemaErrors([
|
|
{ name: "first", inputSchema: { type: "object" }, outputSchema },
|
|
{
|
|
name: "second",
|
|
inputSchema: { type: "object" },
|
|
outputSchema: { ...outputSchema },
|
|
},
|
|
{
|
|
name: "broken",
|
|
inputSchema: { type: "object" },
|
|
outputSchema: { $id: outputSchema.$id, $ref: "#/$defs/missing" },
|
|
},
|
|
]);
|
|
expect(errors).toHaveLength(1);
|
|
expect(errors[0]).toContain("broken.outputSchema");
|
|
expect(errors[0]).toContain("missing");
|
|
});
|
|
|
|
it.each([false, true])(
|
|
"rejects references to another tool's nested IDs (earlier compilation fails: %s)",
|
|
(invalidPrevious) => {
|
|
const nestedId = "urn:rea:test:nested-output";
|
|
const errors = schemaErrors([
|
|
{
|
|
name: "first",
|
|
inputSchema: { type: "object" },
|
|
outputSchema: {
|
|
$defs: { shared: { $id: nestedId, type: "string" } },
|
|
...(invalidPrevious ? { pattern: "[" } : {}),
|
|
},
|
|
},
|
|
{
|
|
name: "broken",
|
|
inputSchema: { type: "object" },
|
|
outputSchema: {
|
|
$ref: nestedId,
|
|
$defs: { shared: { type: "number" } },
|
|
},
|
|
},
|
|
]);
|
|
expect(errors).toHaveLength(invalidPrevious ? 2 : 1);
|
|
const brokenErrors = errors.filter((error) =>
|
|
error.startsWith("broken.outputSchema:"),
|
|
);
|
|
expect(brokenErrors).toHaveLength(1);
|
|
expect(brokenErrors[0]).toContain(nestedId);
|
|
},
|
|
);
|
|
|
|
it("distinguishes recursive references from shared definitions", () => {
|
|
const diamond = {
|
|
type: "object",
|
|
properties: {
|
|
left: { $ref: "#/$defs/shared" },
|
|
right: { $ref: "#/$defs/shared" },
|
|
},
|
|
$defs: { shared: { type: "string" } },
|
|
};
|
|
expect(
|
|
recursiveReferences([{ name: "diamond", inputSchema: diamond }]),
|
|
).toEqual([]);
|
|
expect(
|
|
recursiveReferences([{ name: "root", inputSchema: { $ref: "#" } }]),
|
|
).toEqual(["root.inputSchema: #"]);
|
|
const escaped = {
|
|
$ref: "#/$defs/a~1b",
|
|
$defs: { "a/b": { $ref: "#/$defs/a~1b" } },
|
|
};
|
|
expect(
|
|
recursiveReferences([{ name: "escaped", inputSchema: escaped }]),
|
|
).toEqual(["escaped.inputSchema: #/$defs/a~1b"]);
|
|
});
|