Files
reverse-engineering-anything/tests/boundary/sqlite/sqliteDatabaseFailures.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

182 lines
6.1 KiB
TypeScript

import { ArtifactReaderFailure } from "../../../src/resources/ArtifactReader.js";
import { classifyProviderFailure } from "../../../src/providers/classifyProviderFailure.js";
import { expect, it } from "vitest";
import { OwnedCommandFailure } from "../../../src/process/OwnedCommand.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import { sqliteDatabaseDialect } from "../../../src/sqlite/SqliteDatabaseFailures.js";
import { SQLITE_DATABASE_LIMITS } from "../../../src/sqlite/SqliteDatabaseLimits.js";
import { releaseOwnedCleanup } from "../../support/cleanupRelease.js";
it.each([null, "owned stop unconfirmed"])(
"preserves a selected worker deadline with cleanup=%s",
(cleanup) => {
const cause = new OwnedCommandFailure(
"timeout",
"Command deadline elapsed.",
{
stdout: { text: "partial-owned-output", bytes: 20, observedBytes: 20 },
stderr: { text: "", bytes: 0, observedBytes: 0 },
exitCode: null,
signal: null,
},
cleanup,
undefined,
["pid:owned-fixture"],
);
const failure = classifyProviderFailure(
cause,
sqliteDatabaseDialect("/selected.db", "worker", undefined, 1234),
);
expect(failure.cause).toBe(cause);
const projected = projectAnalysisError(failure);
if (cleanup === null)
expect(projected).toMatchObject({
code: "provider_timeout",
details: {
timeout_ms: 1234,
limit: {
control_kind: "parameter",
parameter: "worker_timeout_ms",
effective_value: 1234,
},
},
remediation: {
action: expect.not.stringContaining("--"),
},
});
else
expect(projected).toMatchObject({
code: "cleanup_incomplete",
retryable: false,
details: {
resources: ["pid:owned-fixture"],
diagnostics: {
previous_error: {
code: "provider_timeout",
details: { timeout_ms: 1234 },
remediation: {
action: expect.stringContaining("worker_timeout_ms"),
},
},
},
},
});
expect(
JSON.stringify(projected).split("partial-owned-output"),
).toHaveLength(2);
if (cleanup !== null) {
expect(failure.cleanupPrimary).toMatchObject({
_tag: "AnalysisTimeoutError",
timeoutMs: 1234,
});
releaseOwnedCleanup(failure);
const resolved = projectAnalysisError(failure);
expect(resolved).toMatchObject({
code: "provider_timeout",
details: { timeout_ms: 1234 },
});
expect(
JSON.stringify(resolved).split("partial-owned-output"),
).toHaveLength(2);
}
},
);
it("does not recommend a timer above the supported maximum", () => {
const failure = projectAnalysisError(
classifyProviderFailure(
new OwnedCommandFailure("timeout", "deadline"),
sqliteDatabaseDialect("/selected.db", "worker", undefined, 2_147_483_647),
),
);
expect(failure.details).toMatchObject({ timeout_ms: 2_147_483_647 });
expect(failure.remediation.action).toContain("no higher worker deadline");
expect(failure.remediation.action).not.toContain("Increase");
});
it("says diagnostic capture has no runtime override", () => {
const projected = projectAnalysisError(
classifyProviderFailure(
new OwnedCommandFailure("output-limit", "diagnostics exceeded"),
sqliteDatabaseDialect("/selected.db", "worker"),
),
);
expect(projected.remediation.action).toContain(
String(SQLITE_DATABASE_LIMITS.diagnosticBytes),
);
expect(projected.remediation.action).toContain("no runtime override");
expect(projected.remediation.action).toContain(
"worker_timeout_ms does not raise it",
);
});
it.each(["/selected.db", "./Database files/another.db"])(
"retains the caller-selected path %s when the owned worker reports V8 heap exhaustion",
(path) => {
const stderr =
"FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory";
const cause = new OwnedCommandFailure("process", "Worker exited.", {
stdout: { text: "", bytes: 0, observedBytes: 0 },
stderr: {
text: stderr,
bytes: Buffer.byteLength(stderr),
observedBytes: Buffer.byteLength(stderr),
},
exitCode: null,
signal: "SIGABRT",
runtimeExhaustion: {
runtime: "v8",
area: "heap",
stream: "stderr",
line: stderr.trim(),
lineComplete: true,
truncated: false,
invalidUtf8: false,
},
});
const failure = classifyProviderFailure(
cause,
sqliteDatabaseDialect(path, "worker"),
);
expect(failure.cause).toBe(cause);
expect(projectAnalysisError(failure)).toMatchObject({
code: "resource_constraint",
details: {
operation: "inspect_sqlite_database",
resource: "memory",
reported_limits: { javascript_heap_bytes: 256 * 1024 * 1024 },
diagnostics: {
selected_path: path,
// The runtime's report survives even when retention dropped it.
runtime_exhaustion_report: {
runtime: "v8",
area: "heap",
stream: "stderr",
line: stderr.trim(),
line_complete: true,
},
},
captured_output: { stderr },
},
});
},
);
it("does not infer cancellation from a later signal when cleanup carries no cancellation fact", () => {
const controller = new AbortController();
const cause = new ArtifactReaderFailure("io", "cleanup remains owned", {
cleanup: { reason: "close failed", resources: ["/owned/reply.json"] },
});
controller.abort(new Error("later caller cancellation"));
const failure = classifyProviderFailure(
cause,
sqliteDatabaseDialect("/selected.db", "worker", controller.signal),
);
expect(failure.cleanupIncomplete).toBe(true);
expect(failure.cleanupPrimary).toBeUndefined();
expect(projectAnalysisError(failure)).toMatchObject({
code: "cleanup_incomplete",
details: { resources: ["/owned/reply.json"] },
});
});