mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 11:43:20 +00:00
* 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.
189 lines
6.1 KiB
TypeScript
189 lines
6.1 KiB
TypeScript
import { fileIdentity } from "../fixtures/evidenceSubject.js";
|
|
import { writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
import { expect } from "vitest";
|
|
import { toolContract } from "../../src/contracts/toolContracts.js";
|
|
import {
|
|
compressedKernelModuleContainer,
|
|
kernelModuleFixture,
|
|
} from "../../src/native/elf/KernelModule.fixture.js";
|
|
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
|
|
import { cliTest } from "../support/cli/cliFixture.js";
|
|
|
|
cliTest(
|
|
"honors modinfo field retention budgets through CLI flags",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-text-cli-");
|
|
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 result = await cli.run({
|
|
arguments: [
|
|
"inspect-kernel-module",
|
|
path,
|
|
"--max-modinfo-key-bytes",
|
|
"257",
|
|
"--max-modinfo-value-bytes",
|
|
"4097",
|
|
"--json",
|
|
],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
|
|
result.json,
|
|
);
|
|
expect(evidence.normalized_result.modinfo?.entries[0]).toMatchObject({
|
|
key,
|
|
value,
|
|
status: "observed",
|
|
reason: null,
|
|
omitted_fields: [],
|
|
});
|
|
expect(evidence.normalized_result.coverage.status).toBe("complete");
|
|
const omitted = await cli.run({
|
|
arguments: [
|
|
"inspect-kernel-module",
|
|
path,
|
|
"--max-modinfo-value-bytes",
|
|
"4096",
|
|
"--full-output",
|
|
"--json",
|
|
],
|
|
});
|
|
expect(omitted.exitCode, omitted.stderr).toBe(0);
|
|
expect((omitted.json as { meta: unknown }).meta).toMatchObject({
|
|
cli_controls: {
|
|
max_modinfo_key_bytes: "--max-modinfo-key-bytes",
|
|
max_modinfo_value_bytes: "--max-modinfo-value-bytes",
|
|
},
|
|
});
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"reports license, duplicate aliases, and version CRCs through the public CLI",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-cli-");
|
|
const path = join(root, "demo.ko");
|
|
await writeFile(path, kernelModuleFixture());
|
|
const result = await cli.run({
|
|
arguments: ["inspect-kernel-module", path, "--json"],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
|
|
result.json,
|
|
);
|
|
expect(
|
|
evidence.normalized_result.modinfo?.entries.map((entry) => [
|
|
entry.key,
|
|
entry.value,
|
|
]),
|
|
).toEqual([
|
|
["license", "GPL"],
|
|
["vermagic", "5.15.0 SMP mod_unload"],
|
|
["alias", "pci:v1"],
|
|
["alias", "pci:v2"],
|
|
["name", "demo"],
|
|
["depends", ""],
|
|
]);
|
|
expect(evidence.normalized_result.versions?.entries[0]?.crc_hex).toBe(
|
|
"0000000012345678",
|
|
);
|
|
expect(evidence.normalized_result.signature?.status).toBe("present");
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"reports duplicate sections as partial through the public CLI",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-duplicate-");
|
|
const path = join(root, "duplicate.ko");
|
|
await writeFile(
|
|
path,
|
|
kernelModuleFixture({
|
|
sharedNameSections: {
|
|
name: ".init.text",
|
|
count: 1,
|
|
body: Buffer.from([1, 2, 3]),
|
|
},
|
|
}),
|
|
);
|
|
const result = await cli.run({
|
|
arguments: ["inspect-kernel-module", path, "--json"],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
|
|
result.json,
|
|
);
|
|
expect(evidence.normalized_result.coverage.status).toBe("partial");
|
|
expect(evidence.normalized_result.init_text).toMatchObject({
|
|
status: "present",
|
|
bytes: 4,
|
|
});
|
|
expect(evidence.normalized_result.limitations).toContain(
|
|
"Multiple .init.text sections are declared; the first is examined.",
|
|
);
|
|
},
|
|
);
|
|
|
|
cliTest(
|
|
"resolves a relative kernel module path against the working directory",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-cli-rel-");
|
|
await writeFile(join(root, "demo.ko"), kernelModuleFixture({ type: 3 }));
|
|
const result = await cli.run({
|
|
arguments: ["inspect-kernel-module", "demo.ko", "--json"],
|
|
cwd: root,
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
|
|
result.json,
|
|
);
|
|
expect(evidence.normalized_result.applicability).toBe("not_applicable");
|
|
expect(evidence.normalized_result.type_name).toBe("shared");
|
|
expect(evidence.subject?.local_path).toBe(join(root, "demo.ko"));
|
|
},
|
|
);
|
|
|
|
cliTest("reports a non-ELF file as invalid input", async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-cli-bad-");
|
|
const path = join(root, "broken.ko");
|
|
await writeFile(path, Buffer.from("not an elf"));
|
|
const result = await cli.run({
|
|
arguments: ["inspect-kernel-module", path, "--json"],
|
|
});
|
|
expect(result.exitCode).toBe(1);
|
|
expect(result.json).toMatchObject({
|
|
code: "invalid_request",
|
|
details: { operation: "inspect_kernel_module" },
|
|
});
|
|
});
|
|
|
|
cliTest(
|
|
"reports a compressed container without claiming the payload is a module",
|
|
async ({ cli }) => {
|
|
const root = await createTestTempDirectory("rea-kernel-module-cli-xz-");
|
|
const path = join(root, "demo.ko.xz");
|
|
await writeFile(path, compressedKernelModuleContainer("xz"));
|
|
const result = await cli.run({
|
|
arguments: ["inspect-kernel-module", path, "--json"],
|
|
});
|
|
expect(result.exitCode, result.stderr).toBe(0);
|
|
const evidence = toolContract("inspect_kernel_module").outputSchema.parse(
|
|
result.json,
|
|
);
|
|
expect(evidence.normalized_result).toMatchObject({
|
|
applicability: "unsupported",
|
|
format: null,
|
|
compression: { codec: "xz", status: "unsupported" },
|
|
next_probe: { operation: "external_decompression" },
|
|
modinfo: null,
|
|
});
|
|
expect(fileIdentity(evidence.subject).format).toBe("file");
|
|
},
|
|
);
|