morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 07:47:29 +00:00

[GH-ISSUE #5405] [Bug] Rust and IL2CPP input-size refusals recommend increasing evidence-output limits #3275

New issue

Closed

opened 2026-10-31 00:38:40 +00:00 by bsakaguchi · 1 comment

bsakaguchi commented

2026-10-31 00:38:40 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 20, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/5405

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

CLI

Observed behavior

inspect-rust-binary and inspect-il2cpp-metadata correctly refuse an input above their fixed 256 MiB limit, but their JSON recovery action tells the caller to increase the file-size allowance for the evidence reply. That advice cannot admit the unchanged oversized input. inspect-go-binary returns input-appropriate recovery advice for the same file.

Reproduction

From the source checkout with dependencies and the built runtime prepared, run this script. It creates a 257 MiB regular sparse file and isolates CLI configuration. An independent verifier ran these three commands twice each and reproduced the same results on both runs.

python3 - <<'PYTHON'
import json, os, pathlib, subprocess, tempfile
work = pathlib.Path(tempfile.mkdtemp(prefix="rea-size-check-"))
env = {k: v for k, v in os.environ.items() if not k.startswith("REA_")}
for key, name in [("HOME", "home"), ("XDG_CONFIG_HOME", "config"),
                  ("XDG_DATA_HOME", "data"), ("XDG_CACHE_HOME", "cache"),
                  ("XDG_STATE_HOME", "state")]:
    folder = work / name
    folder.mkdir()
    env[key] = str(folder)
artifact = work / "oversized.bin"
with artifact.open("wb") as handle:
    handle.truncate(269484032)
for command in ["inspect-go-binary", "inspect-rust-binary", "inspect-il2cpp-metadata"]:
    result = subprocess.run(["node", "scripts/rea.mjs", command, str(artifact), "--json"],
                            env=env, capture_output=True, text=True, timeout=30)
    (work / (command + ".json")).write_text(result.stdout)
    (work / (command + ".stderr")).write_text(result.stderr)
    error = json.loads(result.stdout)
    print(json.dumps({"command": command, "exit": result.returncode,
                      "code": error["code"], "retryable": error["retryable"],
                      "resource": error["details"]["resource"],
                      "limits": error["details"]["reported_limits"],
                      "action": error["remediation"]["action"]}))
PYTHON

Expected behavior

Keep rejecting inputs above the documented fixed allowance, but give recovery advice about selecting a suitable complete artifact within that input allowance. Increasing an evidence-output allowance should not be suggested as a way to admit this input.

docs/rust-binaries.md:49 and docs/il2cpp-metadata.md:179 document the 256 MiB input bounds. docs/go-binaries.md:94-96 distinguishes Go input admission from output-write and transport budgets; the observed Go response is a useful comparison, rather than a requirement for identical wording across providers.

Impact and scope

P3 wording defect, reproduced twice for each affected CLI command. The refusal, numeric input limit, and non-retryable status remain correct. No incorrect analysis result or data loss was observed. A caller can read maximum_input_bytes and select a suitable complete artifact within the allowance; analyzing an oversized artifact remains intentionally unsupported. MCP was not exercised.

REA version

6.7.0; source commit 074768901f3cdc8205b61773fb1faf6f6c7b3ca8.

Runtime and platform

Node v26.12.0; Darwin arm64. No analysis engine is required for this input-admission reproduction.

Target and artifact context

Regular sparse file of 269484032 bytes (257 MiB). Its size is rejected before format parsing, so valid Rust or IL2CPP content is unnecessary.

Interface

CLI

Earliest failure stage

Transport or result projection

Relevant output or evidence

Observed through the built CLI: all three commands exited 1 with empty stderr, code and category equal to resource_constraint, retryable: false, details.resource: "file-size", and details.reported_limits.maximum_input_bytes: 268435456.

Both affected commands returned:

Review the reported worker file-size limits and write failure. Retry with a sufficient file-size allowance for the evidence reply; REA retains tighter inherited limits.

The Go control returned:

Select a suitable stable artifact within the reported input byte allowance. Do not truncate required bytes; retrying the unchanged oversized input will fail again.

Typed outcome or recovery expected

Preserve the existing typed input-size refusal, numeric limit, and non-retryable status. Make the recovery action address the input allowance. Genuine worker output-write failures should retain output-appropriate advice; inducing such a failure is a proposed regression check, not an executed reproduction here.

Analysis or suspected cause

Source-derived reasoning at the tested commit: src/artifacts/readStableArtifact.ts:59-71 rejects excessive size before opening or parsing. src/rust/RustBinaryProvider.ts:271-278 and src/il2cpp/Il2cppMetadataProvider.ts:96-103 translate that input failure without overriding remediation, so src/domain/analysisErrorPresentation.ts:67-78 supplies generic evidence-write advice. src/go/GoBinaryProvider.ts:79-91 supplies input-specific advice for the control.

Additional context

Prepared with AI assistance and independently reproduced through the supported CLI. The submission check fetched upstream main and found no later commits touching the cited contract/failure files. No target execution or network access was needed for the reproduction itself.

Related: #4622 covered the Go input-size path and was closed after its Go-specific fix. This report covers the remaining Rust and IL2CPP paths; Go now serves as the working control.

Originally created by @coygeek on GitHub (Oct 20, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/5405 ### Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area CLI ### Observed behavior `inspect-rust-binary` and `inspect-il2cpp-metadata` correctly refuse an input above their fixed 256 MiB limit, but their JSON recovery action tells the caller to increase the file-size allowance for the evidence reply. That advice cannot admit the unchanged oversized input. `inspect-go-binary` returns input-appropriate recovery advice for the same file. ### Reproduction From the source checkout with dependencies and the built runtime prepared, run this script. It creates a 257 MiB regular sparse file and isolates CLI configuration. An independent verifier ran these three commands twice each and reproduced the same results on both runs. ```sh python3 - <<'PYTHON' import json, os, pathlib, subprocess, tempfile work = pathlib.Path(tempfile.mkdtemp(prefix="rea-size-check-")) env = {k: v for k, v in os.environ.items() if not k.startswith("REA_")} for key, name in [("HOME", "home"), ("XDG_CONFIG_HOME", "config"), ("XDG_DATA_HOME", "data"), ("XDG_CACHE_HOME", "cache"), ("XDG_STATE_HOME", "state")]: folder = work / name folder.mkdir() env[key] = str(folder) artifact = work / "oversized.bin" with artifact.open("wb") as handle: handle.truncate(269484032) for command in ["inspect-go-binary", "inspect-rust-binary", "inspect-il2cpp-metadata"]: result = subprocess.run(["node", "scripts/rea.mjs", command, str(artifact), "--json"], env=env, capture_output=True, text=True, timeout=30) (work / (command + ".json")).write_text(result.stdout) (work / (command + ".stderr")).write_text(result.stderr) error = json.loads(result.stdout) print(json.dumps({"command": command, "exit": result.returncode, "code": error["code"], "retryable": error["retryable"], "resource": error["details"]["resource"], "limits": error["details"]["reported_limits"], "action": error["remediation"]["action"]})) PYTHON ``` ### Expected behavior Keep rejecting inputs above the documented fixed allowance, but give recovery advice about selecting a suitable complete artifact within that input allowance. Increasing an evidence-output allowance should not be suggested as a way to admit this input. `docs/rust-binaries.md:49` and `docs/il2cpp-metadata.md:179` document the 256 MiB input bounds. `docs/go-binaries.md:94-96` distinguishes Go input admission from output-write and transport budgets; the observed Go response is a useful comparison, rather than a requirement for identical wording across providers. ### Impact and scope P3 wording defect, reproduced twice for each affected CLI command. The refusal, numeric input limit, and non-retryable status remain correct. No incorrect analysis result or data loss was observed. A caller can read `maximum_input_bytes` and select a suitable complete artifact within the allowance; analyzing an oversized artifact remains intentionally unsupported. MCP was not exercised. ### REA version 6.7.0; source commit `074768901f3cdc8205b61773fb1faf6f6c7b3ca8`. ### Runtime and platform Node v26.12.0; Darwin arm64. No analysis engine is required for this input-admission reproduction. ### Target and artifact context Regular sparse file of 269484032 bytes (257 MiB). Its size is rejected before format parsing, so valid Rust or IL2CPP content is unnecessary. ### Interface CLI ### Earliest failure stage Transport or result projection ### Relevant output or evidence Observed through the built CLI: all three commands exited 1 with empty stderr, `code` and `category` equal to `resource_constraint`, `retryable: false`, `details.resource: "file-size"`, and `details.reported_limits.maximum_input_bytes: 268435456`. Both affected commands returned: ```text Review the reported worker file-size limits and write failure. Retry with a sufficient file-size allowance for the evidence reply; REA retains tighter inherited limits. ``` The Go control returned: ```text Select a suitable stable artifact within the reported input byte allowance. Do not truncate required bytes; retrying the unchanged oversized input will fail again. ``` ### Typed outcome or recovery expected Preserve the existing typed input-size refusal, numeric limit, and non-retryable status. Make the recovery action address the input allowance. Genuine worker output-write failures should retain output-appropriate advice; inducing such a failure is a proposed regression check, not an executed reproduction here. ### Analysis or suspected cause Source-derived reasoning at the tested commit: `src/artifacts/readStableArtifact.ts:59-71` rejects excessive size before opening or parsing. `src/rust/RustBinaryProvider.ts:271-278` and `src/il2cpp/Il2cppMetadataProvider.ts:96-103` translate that input failure without overriding remediation, so `src/domain/analysisErrorPresentation.ts:67-78` supplies generic evidence-write advice. `src/go/GoBinaryProvider.ts:79-91` supplies input-specific advice for the control. ### Additional context Prepared with AI assistance and independently reproduced through the supported CLI. The submission check fetched upstream main and found no later commits touching the cited contract/failure files. No target execution or network access was needed for the reproduction itself. Related: #4622 covered the Go input-size path and was closed after its Go-specific fix. This report covers the remaining Rust and IL2CPP paths; Go now serves as the working control.

bsakaguchi closed this issue

2026-10-31 00:38:40 +00:00

bsakaguchi commented

2026-10-31 00:38:42 +00:00

Author

Owner

@morluto commented on GitHub (Oct 21, 2026):

Closing as fixed on main by github.com/morluto/rea@ef59174c1e, retained at 67a6477f01.

Rust and IL2CPP oversized-input refusals now name the fixed input allowance and suitable complete-artifact recovery, without advice to increase an Evidence reply limit. Rust has a direct provider-boundary projection regression; IL2CPP uses the same shared recovery helper at its input failure boundary, inspected by source.

This audit inspected the current producer, regression source, issue discussion and main ancestry. Tests/runtime reproductions were not rerun, and no additional real-provider or platform coverage is implied.

@morluto commented on GitHub (Oct 21, 2026): Closing as fixed on main by https://github.com/morluto/rea/commit/ef59174c1edd6ed9adb0722b86a5b9a57217e310, retained at 67a6477f011ae358fc333e5a6e26c86d932654ed. Rust and IL2CPP oversized-input refusals now name the fixed input allowance and suitable complete-artifact recovery, without advice to increase an Evidence reply limit. Rust has a direct provider-boundary projection regression; IL2CPP uses the same shared recovery helper at its input failure boundary, inspected by source. This audit inspected the current producer, regression source, issue discussion and main ancestry. Tests/runtime reproductions were not rerun, and no additional real-provider or platform coverage is implied.

bsakaguchi referenced this issue

2026-10-31 01:08:42 +00:00

[PR #3275] test(setup): sweep supported client lifecycle symmetry #5692

No milestone

No project

No assignees

1 participant

Notifications

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

morluto/rea#3275

No description provided.

Rows
Columns