mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 19:53:50 +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.
147 lines
5.4 KiB
TypeScript
147 lines
5.4 KiB
TypeScript
import { truncate, writeFile } from "node:fs/promises";
|
|
import { join } from "node:path";
|
|
|
|
import { expect, it } from "vitest";
|
|
|
|
import { parseBinaryTarget } from "../../../src/application/BinaryTargetResolver.js";
|
|
import { enhancedInputSchemas } from "../../../src/contracts/enhancedInputs.js";
|
|
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
|
import {
|
|
DEFAULT_DISPATCH_METADATA_INPUT_BYTES,
|
|
MAXIMUM_DISPATCH_METADATA_INPUT_BYTES,
|
|
} from "../../../src/domain/native/objcSwiftMetadata.js";
|
|
import {
|
|
appleDispatchMetadataFailure,
|
|
inspectAppleDispatchMetadata,
|
|
} from "../../../src/native/AppleDispatchMetadata.js";
|
|
import { withArtifactResourceScope } from "../../fixtures/artifactInventory.js";
|
|
import { machoWithPropertyAttributes } from "../../fixtures/objcPropertyMacho.js";
|
|
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
|
|
|
|
const fixtureTarget = async (bytes: Buffer, name = "fixture.bin") => {
|
|
const directory = await createTestTempDirectory("rea-dispatch-budget-");
|
|
const path = join(directory, name);
|
|
await writeFile(path, bytes);
|
|
const target = await parseBinaryTarget(path);
|
|
if (!target.ok) throw target.error;
|
|
return { path, target: target.value };
|
|
};
|
|
|
|
const inspect = (
|
|
target: Awaited<ReturnType<typeof fixtureTarget>>["target"],
|
|
maxInputBytes?: number,
|
|
) =>
|
|
withArtifactResourceScope((resources) =>
|
|
resources.run(() =>
|
|
inspectAppleDispatchMetadata(target, 100, resources, { maxInputBytes }),
|
|
),
|
|
);
|
|
|
|
const refusal = async (
|
|
path: string,
|
|
run: () => Promise<unknown>,
|
|
): Promise<ReturnType<typeof projectAnalysisError>> => {
|
|
const failure = await run().then(
|
|
() => undefined,
|
|
(cause: unknown) => cause,
|
|
);
|
|
if (failure === undefined) throw new Error("Expected a budget refusal");
|
|
return projectAnalysisError(appleDispatchMetadataFailure(failure, path));
|
|
};
|
|
|
|
it("records the default budget and the caller-selected budget it read under", async () => {
|
|
const bytes = machoWithPropertyAttributes("Tq,N");
|
|
const { target } = await fixtureTarget(bytes);
|
|
await expect(inspect(target)).resolves.toMatchObject({
|
|
input_admission: {
|
|
maximum_bytes: DEFAULT_DISPATCH_METADATA_INPUT_BYTES,
|
|
source: "default",
|
|
retained_bytes: bytes.length,
|
|
},
|
|
});
|
|
const exact = await inspect(target, bytes.length);
|
|
expect(exact.input_admission).toEqual({
|
|
maximum_bytes: bytes.length,
|
|
source: "caller",
|
|
retained_bytes: bytes.length,
|
|
});
|
|
// The budget changes admission only, never the decoded metadata.
|
|
expect(exact.result).toEqual((await inspect(target)).result);
|
|
});
|
|
|
|
it("names the observed size, effective budget, its source and the budget to select", async () => {
|
|
const bytes = machoWithPropertyAttributes("Tq,N");
|
|
const { path, target } = await fixtureTarget(bytes);
|
|
const projected = await refusal(path, () =>
|
|
inspect(target, bytes.length - 1),
|
|
);
|
|
expect(projected).toMatchObject({
|
|
code: "resource_constraint",
|
|
retryable: false,
|
|
message: `Apple static metadata input (${String(bytes.length)} bytes) exceeds the selected max_input_bytes of ${String(bytes.length - 1)} bytes.`,
|
|
remediation: {
|
|
action: `Retry with max_input_bytes of at least ${String(bytes.length)}, at most 1073741824 bytes (1 GiB); REA holds that many bytes in memory for the read.`,
|
|
},
|
|
details: {
|
|
reported_limits: {
|
|
input_bytes: bytes.length - 1,
|
|
input_bytes_source: "caller",
|
|
maximum_selectable_input_bytes: MAXIMUM_DISPATCH_METADATA_INPUT_BYTES,
|
|
observed_input_bytes: bytes.length,
|
|
},
|
|
limit: {
|
|
control_kind: "parameter",
|
|
parameter: "max_input_bytes",
|
|
effective_value: bytes.length - 1,
|
|
maximum: MAXIMUM_DISPATCH_METADATA_INPUT_BYTES,
|
|
},
|
|
},
|
|
});
|
|
expect(JSON.stringify(projected)).not.toContain("no runtime override");
|
|
expect(JSON.stringify(projected)).not.toContain("--");
|
|
});
|
|
|
|
it("refuses files above the default without opt-in and points past the maximum to a deep provider", async () => {
|
|
// Sparse files: admission is decided from the stat size before any read.
|
|
const bytes = machoWithPropertyAttributes("Tq,N");
|
|
for (const [size, source, action] of [
|
|
[
|
|
DEFAULT_DISPATCH_METADATA_INPUT_BYTES + 1,
|
|
"default",
|
|
`of at least ${String(DEFAULT_DISPATCH_METADATA_INPUT_BYTES + 1)}`,
|
|
],
|
|
[
|
|
MAXIMUM_DISPATCH_METADATA_INPUT_BYTES + 1,
|
|
"caller",
|
|
"use a deep analysis provider",
|
|
],
|
|
] as const) {
|
|
const { path, target } = await fixtureTarget(bytes, `large-${source}.bin`);
|
|
await truncate(path, size);
|
|
const projected = await refusal(path, () =>
|
|
inspect(
|
|
target,
|
|
source === "caller" ? MAXIMUM_DISPATCH_METADATA_INPUT_BYTES : undefined,
|
|
),
|
|
);
|
|
expect(projected.details).toMatchObject({
|
|
reported_limits: {
|
|
input_bytes_source: source,
|
|
observed_input_bytes: size,
|
|
},
|
|
});
|
|
expect(projected.remediation.action).toContain(action);
|
|
}
|
|
});
|
|
|
|
it("validates max_input_bytes at the shared input contract", () => {
|
|
const schema = enhancedInputSchemas.inspect_native_dispatch_metadata;
|
|
expect(schema.parse({}).max_input_bytes).toBeUndefined();
|
|
expect(
|
|
schema.parse({ max_input_bytes: MAXIMUM_DISPATCH_METADATA_INPUT_BYTES })
|
|
.max_input_bytes,
|
|
).toBe(MAXIMUM_DISPATCH_METADATA_INPUT_BYTES);
|
|
for (const value of [0, -1, 1.5, MAXIMUM_DISPATCH_METADATA_INPUT_BYTES + 1])
|
|
expect(schema.safeParse({ max_input_bytes: value }).success).toBe(false);
|
|
});
|