Files
reverse-engineering-anything/tests/boundary/mcp/kernelModuleMcp.test.ts
T
morluto 2430b081c9 refactor(providers): bind provider refusals' per-call controls instead of naming CLI flags (#11455)
* refactor(native): bind producer_limits and max_input_bytes as the per-call controls of pwntools and Apple dispatch refusals

producerLimitControl in src/domain/producerResourceLimits.ts names one producer budget as producer_limits.<field>; the shared provider outcome classifier now carries a resource signal's limit. Pwntools file-size, CPU and output refusals and the Apple dispatch input refusal bind their control, and their remediation no longer names CLI flags.

* fix(native): report the selected output allowance as the omitted file_bytes default

* fix(native): bind producer_limits.diagnostic_bytes as the pwntools command output-limit control

* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals (#11458)

* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals

* test(rust): cover the complete-report refusal's producer_limits control

* refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags (#11466)

* refactor(rust): bind producer_limits as the per-call control of Rust input and report refusals

* test(rust): cover the complete-report refusal's producer_limits control

* refactor(browser): bind caller-selectable browser deadlines as per-call controls instead of naming CLI flags

deadlineParameterLimit in src/domain/analysisResourceLimits.ts owns the millisecond deadline control that nativeDeadlineRecovery and the browser recoveries share. CDP command and discovery, web bundle per-script and total, network capture and source-map decode deadlines now carry it; browserDeadlineIncrease no longer takes CLI flag text.

* fix(browser): record a per-script deadline's parameter control in partial web bundle results

* refactor(providers): bind Wabt, SQLite, EVMole, Apktool and Go controls instead of naming CLI commands (#11472)

* refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands

These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control.

* refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags

* fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails

* ci(guards): count template-built CLI option and command text outside the CLI layer (#11478)

* refactor(providers): bind Wabt, SQLite, EVMole and Apktool deadline and byte controls instead of naming CLI commands

These remediation strings named rea commands and flags through template text the cli-option guard did not count. Wabt byte refusals and output limits bind max_input_bytes, max_tool_bytes or max_output_bytes while a larger value is selectable; SQLite worker_timeout_ms, EVMole timeout_ms and Apktool decode_timeout_ms bind through deadlineParameterLimit; the shared provider outcome classifier now carries an output limit's control.

* refactor(go): bind Go analysis budgets as per-call controls instead of naming CLI flags

* fix(providers): keep the typed primary when Wabt, EVMole or pwntools command cleanup fails

* ci(guards): count template-built CLI option and command text outside the CLI layer

The cli-option-text-outside-cli pattern now also matches "(CLI ...", "on the CLI", "or use rea ..." and backticked `rea <command>` references, so remediation built from a template such as --${name} or rea inspect-... <path> is counted. Doctor.ts is exempt: setup and doctor run only through the CLI. The baseline records the newly counted pre-existing sites (22 -> 45 across 21 files).

* ci(guards): extract the CLI text matcher, exempt host-only commands with written reasons, and test each spelling

* ci(guards): exempt a host-only command and its own arguments in any matched CLI phrase

* fix(native): bind producer_limits.output_bytes for oversized pwndbg debugger replies through one owner

* fix(cli): name an Evidence target source failure's control by the source option that sets it

* feat(cli): render the flags of result-recorded controls in the full-output envelope (#11507)

* feat(cli): render the flags of result-recorded controls in the full-output envelope

* fix(cli): collect result controls only for a full-output envelope, in its requested format, past undefined values

* ci(guards): end a host-only command's arguments before the next CLI command

* refactor(reverse): record the output budget that stopped a one-shot command as a parameter control (#11528)

* fix(cli): read result controls only at positions the output schema declares as recorded controls

* refactor(providers): record the controls that bounded Rust compiler paths and kernel module text instead of naming CLI options (#11532)

* refactor(rust): record the control that bounded compiler-path coverage instead of naming CLI options

* refactor(native): record the controls that omitted kernel module .modinfo text instead of naming CLI options (#11534)

* fix(rust): describe compiler coverage from the retained result after report trimming

* refactor(providers): record managed representation and JavaScript semantic ceiling controls instead of naming CLI options (#11537)

* refactor(managed): record the representation budget on a resource-limit issue instead of naming its CLI option

* refactor(javascript): record the semantic retention ceilings that stopped a graph instead of naming CLI options (#11540)

* fix(cli): name a composed command's source options for the controls its result records

* fix(cli): read result controls from the delivered Evidence when a summary wraps it

* fix(rust): keep the report-byte control recorded when trimming omits every compiler path

When the complete-report allowance left room for no compiler path, rustc_commit became null and its coverage.limit was lost, so --full-output could not name the option that raises the allowance. The report now records rustc_commit_omission { reason, limit } outside the dropped record, and the summary view carries it.

* refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option (#11541)

* refactor(flutter): record the string-pool budgets that left a projection partial instead of naming the CLI option

* test(flutter): assert the complete set of recorded string-pool budgets

* feat(cli): name the options of controls a failure's partial Evidence records (#11557)

meta.cli_controls was collected only from a successful result. A failure whose partial observation is Evidence of the command's own operation is now read the same way, at the positions the output schema declares as recorded controls; Evidence of another operation or a retained reference is not read. When --evidence_output publishes the partial, the delivery records it before replacing it.

* refactor(javascript): record the evaluator budgets that limited sources instead of naming the CLI option (#11564)

Per-value unknown reasons and the Electron wrapper limitation named --semantic-precision. The static examination now records the semantic_precision controls that limited a source (examination.controls), and analyze_javascript_application's semantic_graph.coverage.controls records every evaluator budget that limited any source (examination and semantic IR coverage), beside the retention ceilings. The CLI renders --semantic-precision from those records in meta.cli_controls; the reason texts name only the contract field.
2026-11-16 07:12:16 +08:00

248 lines
8.6 KiB
TypeScript

import { fileIdentity } from "../../fixtures/evidenceSubject.js";
import { canonicalOutputSchema } from "../../fixtures/canonicalOutputSchema.js";
import { writeFile } from "node:fs/promises";
import { Ajv2020 } from "ajv/dist/2020.js";
import type { AnySchema } from "ajv";
import { join } from "node:path";
import { expect } from "vitest";
import { toolContract } from "../../../src/contracts/toolContracts.js";
import { createServer } from "../../../src/server/createServer.js";
import { createTestBinarySession } from "../../fixtures/binarySession.js";
import { parseMcpToolError } from "../../fixtures/mcpToolError.js";
import {
compressedKernelModuleContainer,
kernelModuleFixture,
} from "../../../src/native/elf/KernelModule.fixture.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
import { mcpTest, type TestMcp } from "../../support/mcp/mcpFixture.js";
const connect = async (mcp: TestMcp) => {
const session = createTestBinarySession(() => {
throw new Error("Kernel module inspection must not start a deep provider");
});
const client = await mcp.connect(createServer({ kind: "session", session }));
return { client, session };
};
mcpTest(
"keeps valid omitted modinfo fields distinct from malformed syntax and recovers on the same connection",
async ({ mcp }) => {
const { client, session } = await connect(mcp);
try {
const root = await createTestTempDirectory("rea-kernel-module-text-mcp-");
const path = join(root, "text.ko");
const key = "k".repeat(257);
const value = "v".repeat(4097);
await writeFile(
path,
kernelModuleFixture({ modinfo: Buffer.from(`${key}=${value}\0`) }),
);
const inspect = async (budgets: Record<string, number> = {}) => {
const response = await client.callTool({
name: "inspect_kernel_module",
arguments: { path, ...budgets },
});
expect(response.isError, JSON.stringify(response.content)).not.toBe(
true,
);
return toolContract("inspect_kernel_module").outputSchema.parse(
response.structuredContent,
);
};
const initial = await inspect();
const omitted = initial.normalized_result.modinfo?.entries[0];
expect(omitted).toMatchObject({
status: "observed",
reason: null,
key: null,
value: null,
omitted_fields: ["key", "value"],
raw_hex: null,
});
expect(initial.normalized_result.coverage.status).toBe("partial");
expect(initial.normalized_result.limitations).toEqual(
expect.arrayContaining([
expect.stringContaining("max_modinfo_key_bytes at least 257"),
expect.stringContaining("max_modinfo_value_bytes at least 4097"),
]),
);
// The result records each control by contract field; MCP text names no
// CLI option.
expect(initial.normalized_result.modinfo?.omission_limits).toEqual([
{
control_kind: "parameter",
parameter: "max_modinfo_key_bytes",
effective_value: 256,
unit: "bytes",
minimum: 1,
maximum: 536870912,
default_value: 256,
applies_at: "next_call",
},
expect.objectContaining({
parameter: "max_modinfo_value_bytes",
effective_value: 4096,
default_value: 4096,
}),
]);
expect(initial.normalized_result.limitations.join(" ")).not.toContain(
"--max-modinfo",
);
const recovered = await inspect({
max_modinfo_key_bytes: 257,
max_modinfo_value_bytes: 4097,
});
expect(recovered.subject).toEqual(initial.subject);
expect(recovered.normalized_result.modinfo?.entries[0]).toEqual({
...omitted,
key,
value,
omitted_fields: [],
});
expect(recovered.normalized_result.coverage.status).toBe("complete");
expect(recovered.normalized_result.modinfo).not.toHaveProperty(
"omission_limits",
);
} finally {
await session.close();
}
},
);
mcpTest(
"advertises inspect_kernel_module and reads an ELF32 big-endian module",
async ({ mcp }) => {
const { client, session } = await connect(mcp);
try {
const advertised = (await client.listTools()).tools.find(
(tool) => tool.name === "inspect_kernel_module",
);
expect(advertised?.annotations).toMatchObject({
readOnlyHint: false,
idempotentHint: true,
});
const root = await createTestTempDirectory("rea-kernel-module-mcp-");
const path = join(root, "demo.ko");
await writeFile(path, kernelModuleFixture({ bits: 32, little: false }));
const response = await client.callTool({
name: "inspect_kernel_module",
arguments: { path },
});
expect(response.isError, JSON.stringify(response.content)).not.toBe(true);
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
response.structuredContent,
);
expect(evidence.normalized_result).toMatchObject({
format: "elf32",
byte_order: "big",
machine: 20,
applicability: "applicable",
});
expect(fileIdentity(evidence.subject).architecture).toBe("powerpc");
expect(evidence.normalized_result.modinfo?.entries[0]).toMatchObject({
key: "license",
value: "GPL",
});
expect(evidence.normalized_result.versions?.entries[1]?.crc_hex).toBe(
"90abcdef",
);
} finally {
await session.close();
}
},
);
mcpTest(
"reports duplicate sections as partial in MCP Evidence",
async ({ mcp }) => {
const { client, session } = await connect(mcp);
try {
const root = await createTestTempDirectory(
"rea-kernel-module-duplicate-mcp-",
);
const path = join(root, "duplicate.ko");
await writeFile(
path,
kernelModuleFixture({
sharedNameSections: {
name: ".exit.text",
count: 1,
body: Buffer.from([1, 2, 3]),
},
}),
);
const response = await client.callTool({
name: "inspect_kernel_module",
arguments: { path },
});
expect(response.isError, JSON.stringify(response.content)).not.toBe(true);
const outputSchema = canonicalOutputSchema("inspect_kernel_module");
const ajv = new Ajv2020({ strict: false, validateFormats: false });
expect(ajv.validateSchema(outputSchema as AnySchema)).toBe(true);
expect(
ajv.compile(outputSchema as AnySchema)(response.structuredContent),
).toBe(true);
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
response.structuredContent,
);
expect(evidence.normalized_result.coverage.status).toBe("partial");
expect(evidence.normalized_result.exit_text).toMatchObject({
status: "present",
bytes: 1,
});
expect(evidence.normalized_result.limitations).toContain(
"Multiple .exit.text sections are declared; the first is examined.",
);
} finally {
await session.close();
}
},
);
mcpTest(
"requires an absolute path for inspect_kernel_module",
async ({ mcp }) => {
const { client, session } = await connect(mcp);
try {
const response = await client.callTool({
name: "inspect_kernel_module",
arguments: { path: "demo.ko" },
});
expect(response.isError).toBe(true);
expect(parseMcpToolError(response).error).toMatchObject({
code: "invalid_request",
details: { operation: "inspect_kernel_module" },
});
} finally {
await session.close();
}
},
);
mcpTest(
"reports a zstd container as an unsupported kernel-module target",
async ({ mcp }) => {
const { client, session } = await connect(mcp);
try {
const root = await createTestTempDirectory("rea-kernel-module-zstd-mcp-");
const path = join(root, "demo.ko.zst");
await writeFile(path, compressedKernelModuleContainer("zstd"));
const response = await client.callTool({
name: "inspect_kernel_module",
arguments: { path },
});
expect(response.isError, JSON.stringify(response.content)).not.toBe(true);
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
response.structuredContent,
);
expect(evidence.normalized_result).toMatchObject({
applicability: "unsupported",
compression: { codec: "zstd", status: "unsupported" },
next_probe: { operation: "external_decompression" },
});
} finally {
await session.close();
}
},
);