Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Kaoru0822andClaude Opus 5.5
|
528da7cc31 |
No files matched your search
@@ -60,7 +60,6 @@ jobs:
|
||||
web_runtime: ${{ steps.plan.outputs.web_runtime }}
|
||||
web_source_map: ${{ steps.plan.outputs.web_source_map }}
|
||||
nativeaot: ${{ steps.plan.outputs.nativeaot }}
|
||||
ghidra_bridge: ${{ steps.plan.outputs.ghidra_bridge }}
|
||||
website: ${{ steps.plan.outputs.website }}
|
||||
matrix: ${{ steps.plan.outputs.matrix }}
|
||||
test_selection: ${{ steps.plan.outputs.test_selection }}
|
||||
@@ -140,11 +139,6 @@ jobs:
|
||||
- name: Validate workflow syntax and expressions
|
||||
if: needs.changes.outputs.workflows == 'true'
|
||||
run: go run github.com/rhysd/actionlint/cmd/actionlint@v1.7.7 -shellcheck= -pyflakes=
|
||||
# Code tiers run this source-only policy test in their existing shards.
|
||||
# Workflow-only changes need the guard, without preparing runtime artifacts.
|
||||
- name: Check action pins for workflow-only changes
|
||||
if: needs.changes.outputs.workflows == 'true' && needs.changes.outputs.code != 'true'
|
||||
run: node scripts/run-exact-tests.mjs run tests/boundary/filesystem/workflowActionPinning.test.ts
|
||||
- name: Record static task source and execution identity
|
||||
continue-on-error: true
|
||||
if: needs.changes.outputs.code == 'true'
|
||||
@@ -747,7 +741,6 @@ jobs:
|
||||
tests/boundary/filesystem/javascriptApplicationWorkflows.test.ts
|
||||
tests/boundary/filesystem/webScriptManifestPaths.test.ts
|
||||
tests/boundary/process/ProcessEvidence.host.test.ts
|
||||
tests/boundary/process/packageNpmInvocation.test.ts
|
||||
tests/boundary/process/windowsOutputCapture.test.ts
|
||||
tests/acceptance/webModuleCli.test.ts
|
||||
tests/acceptance/webSourceLocationCli.test.ts
|
||||
@@ -905,11 +898,6 @@ jobs:
|
||||
if: needs.changes.outputs.nativeaot == 'true'
|
||||
uses: ./.github/workflows/nativeaot-fixtures.yml
|
||||
|
||||
ghidra_bridge:
|
||||
needs: [changes, static]
|
||||
if: needs.changes.outputs.ghidra_bridge == 'true'
|
||||
uses: ./.github/workflows/ghidra-bridge-sources.yml
|
||||
|
||||
website:
|
||||
needs: [changes, static]
|
||||
if: needs.changes.outputs.website == 'true'
|
||||
@@ -945,7 +933,6 @@ jobs:
|
||||
web_runtime,
|
||||
web_source_map,
|
||||
nativeaot,
|
||||
ghidra_bridge,
|
||||
website,
|
||||
]
|
||||
runs-on: ubuntu-24.04
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
name: Ghidra bridge source compilation
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
workflow_call:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
env:
|
||||
HUSKY: "0"
|
||||
|
||||
jobs:
|
||||
ghidra-bridge-sources:
|
||||
name: Compile packaged Ghidra bridge sources
|
||||
runs-on: ubuntu-24.04
|
||||
timeout-minutes: 15
|
||||
env:
|
||||
GHIDRA_RELEASE_URL: https://github.com/NationalSecurityAgency/ghidra/releases/download/Ghidra_12.1.4_build/ghidra_12.1.4_PUBLIC_20260921.zip
|
||||
GHIDRA_RELEASE_SHA256: ddac49f903da9d5bac833e5cc79395098b9c33cfd3279be5f31bd00387d2d4db
|
||||
steps:
|
||||
- uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
|
||||
- uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
|
||||
with:
|
||||
node-version-file: .nvmrc
|
||||
- name: Validate the SDK pin against the provider's verified release
|
||||
run: node scripts/verify-ghidra-bridge-sources.mjs --check-sdk-pin >> "$GITHUB_ENV"
|
||||
# Only the jars and application.properties are extracted: the check
|
||||
# compiles against them and never launches Ghidra or imports a target.
|
||||
- name: Acquire checksum-verified Ghidra jars in isolated runner storage
|
||||
shell: bash
|
||||
run: |
|
||||
ghidra_root="${RUNNER_TEMP}/rea-ghidra"
|
||||
mkdir -p "${ghidra_root}"
|
||||
curl -fsSL --retry 3 --write-out 'ghidra_download_bytes=%{size_download} ghidra_download_seconds=%{time_total}\n' -o "${ghidra_root}/ghidra.zip" "${GHIDRA_RELEASE_URL}"
|
||||
echo "${GHIDRA_RELEASE_SHA256} ${ghidra_root}/ghidra.zip" | sha256sum -c -
|
||||
unzip -q "${ghidra_root}/ghidra.zip" '*/Ghidra/*.jar' '*/Ghidra/application.properties' -d "${ghidra_root}"
|
||||
rm "${ghidra_root}/ghidra.zip"
|
||||
properties="$(find "${ghidra_root}" -path '*/Ghidra/application.properties' -print -quit)"
|
||||
test -n "${properties}"
|
||||
echo "GHIDRA_INSTALL_DIR=$(dirname "$(dirname "${properties}")")" >> "${GITHUB_ENV}"
|
||||
# JAVA_HOME_<major>_X64 comes from the runner image, not the env context.
|
||||
- name: Compile bridge sources with the verified runner JDK
|
||||
shell: bash
|
||||
run: |
|
||||
java_home_variable="JAVA_HOME_${GHIDRA_JAVA_MAJOR}_X64"
|
||||
test -n "${!java_home_variable}"
|
||||
JAVA_HOME="${!java_home_variable}" npm run verify:ghidra:bridge-sources -- --verified-sdk
|
||||
@@ -22,7 +22,7 @@ jobs:
|
||||
sudo apt-get update
|
||||
sudo apt-get install --no-install-recommends -y g++-mingw-w64-x86-64
|
||||
- run: npm run build:windows-native
|
||||
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: cutter-windows-native
|
||||
path: native/windows/build/
|
||||
@@ -53,7 +53,7 @@ jobs:
|
||||
uses: ./.github/actions/npm-cache
|
||||
- run: npm ci
|
||||
- if: matrix.platform == 'Windows'
|
||||
uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: cutter-windows-native
|
||||
path: native/windows/build/
|
||||
@@ -67,7 +67,7 @@ jobs:
|
||||
env:
|
||||
EXPECTED_PLATFORM: ${{ matrix.platform }}
|
||||
run: npm run verify:cutter
|
||||
- uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
|
||||
- uses: actions/upload-artifact@v4
|
||||
if: always()
|
||||
with:
|
||||
name: cutter-upstream-${{ matrix.platform }}
|
||||
|
||||
@@ -20,8 +20,6 @@ Give each interpretation and resource a clear owner. Consumers must use that own
|
||||
|
||||
Keep proof of ownership separate from validity, editability, and readiness. Malformed owned data may still be safely removable. Unresolved identity or applicability must remain unknown rather than be treated as absent, foreign, or aligned.
|
||||
|
||||
For lifecycle changes, follow [ownership and completion invariants](docs/tool-design.md#own-the-lifecycle) and select the applicable [lifecycle regressions](docs/testing.md#lifecycle-regressions). Include late handshakes, cancellation during final cleanup, mixed child outcomes, and cleanup retry where those stages exist; active-execution cancellation alone does not cover finalization.
|
||||
|
||||
Assess brittleness in touched code during implementation, debugging, review, and maintenance. Fix the producing representation or ownership rule before adding downstream repairs. Normalize once at the owning boundary using format-aware parsers. Remove superseded representations, aliases, wrappers, and redundant tests after verifying affected consumers. Introduce abstractions only when they remove observed complexity.
|
||||
|
||||
When fixing a bug, inspect the producing boundary and affected consumers for duplicated interpretation or unclear ownership. Complete any directly related refactor in the same change and remove superseded code. Passing regression tests alone does not establish that the brittleness is resolved. If related cleanup remains, explain what remains and why.
|
||||
|
||||
@@ -1057,10 +1057,6 @@ def _serve_connection(connection):
|
||||
):
|
||||
raise PermissionError("Invalid bridge capability")
|
||||
authenticated = True
|
||||
# The connection grace period only bounds unauthenticated idle
|
||||
# clients. Native analysis and a connected owner's idle time
|
||||
# remain unbounded after capability validation.
|
||||
connection.settimeout(None)
|
||||
_write_message(file, {"id": request_id, "event": {
|
||||
"type": "progress",
|
||||
"phase": "hopper_bridge",
|
||||
@@ -1152,17 +1148,13 @@ def _run():
|
||||
server.bind(REA_SOCKET)
|
||||
os.chmod(REA_SOCKET, 0o600)
|
||||
server.listen(1)
|
||||
# A bridge can start after its caller's startup/cleanup deadline. Bound
|
||||
# the first accept as well as reconnects so an orphan cannot pin Hopper's
|
||||
# dedicated Python thread and prevent later documents from starting REA.
|
||||
server.settimeout(REA_RECONNECT_TIMEOUT_SECONDS)
|
||||
try:
|
||||
while True:
|
||||
try:
|
||||
connection, _ = server.accept()
|
||||
except socket.timeout:
|
||||
break
|
||||
connection.settimeout(REA_RECONNECT_TIMEOUT_SECONDS)
|
||||
connection.settimeout(None)
|
||||
if _serve_connection(connection):
|
||||
break
|
||||
# Match REA's cleanup handshake budget without pinning Hopper's
|
||||
|
||||
@@ -555,38 +555,6 @@ def _failed_launch_description(process):
|
||||
return None
|
||||
|
||||
|
||||
def _retire_failed_launch(process, config, listener, stdout, stderr):
|
||||
"""Reconcile an SBProcess returned alongside a failed Launch error."""
|
||||
if not process.IsValid():
|
||||
stdout.close()
|
||||
stderr.close()
|
||||
return False
|
||||
|
||||
pid = process.GetProcessID()
|
||||
if pid > 0:
|
||||
# Even an already-exited process needs its PID published so the host
|
||||
# can distinguish a completed launch failure from an unknown target.
|
||||
with open(config["pid_path"], "w") as handle:
|
||||
handle.write(str(pid))
|
||||
|
||||
if process.GetState() != lldb.eStateExited:
|
||||
stdout.mark_launched()
|
||||
stderr.mark_launched()
|
||||
if pid > 0:
|
||||
# Hold a surviving target until the host has captured its start
|
||||
# identity. If that proof is unavailable, Kill still addresses
|
||||
# this exact SBProcess created by the current launch request.
|
||||
_wait_for_identity_ack(config)
|
||||
process.Kill()
|
||||
_wait_for_exit(listener, process, 5)
|
||||
|
||||
exit_observed = process.GetState() == lldb.eStateExited
|
||||
expected_exit = exit_observed
|
||||
stdout.close(expected_exit=expected_exit)
|
||||
stderr.close(expected_exit=expected_exit)
|
||||
return exit_observed
|
||||
|
||||
|
||||
def trace(debugger, config):
|
||||
global _TRACE_CONTEXT
|
||||
debugger.SetAsync(True)
|
||||
@@ -662,9 +630,8 @@ def trace(debugger, config):
|
||||
)
|
||||
process = target.Launch(_launch_info(target, config, listener), error)
|
||||
if not error.Success() or not process.IsValid():
|
||||
exit_observed = _retire_failed_launch(
|
||||
process, config, listener, stdout, stderr
|
||||
)
|
||||
stdout.close()
|
||||
stderr.close()
|
||||
return {
|
||||
"status": "launch-error",
|
||||
"error": error.GetCString(),
|
||||
@@ -673,26 +640,15 @@ def trace(debugger, config):
|
||||
if process.IsValid()
|
||||
else {}
|
||||
),
|
||||
**(
|
||||
{"target_process_exit_observed": True}
|
||||
if exit_observed
|
||||
else {}
|
||||
),
|
||||
}
|
||||
launch_failure = _failed_launch_description(process)
|
||||
if launch_failure is not None:
|
||||
exit_observed = _retire_failed_launch(
|
||||
process, config, listener, stdout, stderr
|
||||
)
|
||||
stdout.close(expected_exit=True)
|
||||
stderr.close(expected_exit=True)
|
||||
return {
|
||||
"status": "launch-error",
|
||||
"error": launch_failure,
|
||||
"target_process_created": True,
|
||||
**(
|
||||
{"target_process_exit_observed": True}
|
||||
if exit_observed
|
||||
else {}
|
||||
),
|
||||
}
|
||||
stdout.mark_launched()
|
||||
stderr.mark_launched()
|
||||
|
||||
@@ -15,8 +15,6 @@ fake_lldb = sys.modules.setdefault("lldb", types.ModuleType("lldb"))
|
||||
fake_lldb.LLDB_INVALID_ADDRESS = -1
|
||||
fake_lldb.eLaunchFlagDebug = 2
|
||||
fake_lldb.eLaunchFlagStopAtEntry = 4
|
||||
fake_lldb.eStateExited = 10
|
||||
fake_lldb.SBEvent = lambda: object()
|
||||
spec = importlib.util.spec_from_file_location(
|
||||
"rea_lldb_tracer", os.path.join(os.path.dirname(__file__), "rea_lldb_tracer.py")
|
||||
)
|
||||
@@ -25,136 +23,6 @@ spec.loader.exec_module(tracer)
|
||||
|
||||
|
||||
class NativeTraceBudgetTests(unittest.TestCase):
|
||||
def test_failed_launch_does_not_infer_exit_from_a_failed_kill(self):
|
||||
class Process:
|
||||
def IsValid(self):
|
||||
return True
|
||||
|
||||
def GetProcessID(self):
|
||||
return 12345
|
||||
|
||||
def GetState(self):
|
||||
return 6
|
||||
|
||||
def Kill(self):
|
||||
return None
|
||||
|
||||
class Sink:
|
||||
close_exit = None
|
||||
|
||||
def mark_launched(self):
|
||||
pass
|
||||
|
||||
def close(self, expected_exit=False):
|
||||
self.close_exit = expected_exit
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
stdout, stderr = Sink(), Sink()
|
||||
with patch.object(tracer, "_wait_for_identity_ack", return_value="unavailable"), patch.object(
|
||||
tracer, "_wait_for_exit", return_value=None
|
||||
):
|
||||
exited = tracer._retire_failed_launch(
|
||||
Process(), {"pid_path": os.path.join(directory, "pid")}, object(), stdout, stderr
|
||||
)
|
||||
self.assertFalse(exited)
|
||||
self.assertFalse(stdout.close_exit)
|
||||
self.assertFalse(stderr.close_exit)
|
||||
|
||||
def test_failed_launch_publishes_pid_and_retires_live_process(self):
|
||||
class Process:
|
||||
state = 6
|
||||
killed = False
|
||||
|
||||
def IsValid(self):
|
||||
return True
|
||||
|
||||
def GetProcessID(self):
|
||||
return 12345
|
||||
|
||||
def GetState(self):
|
||||
return self.state
|
||||
|
||||
def Kill(self):
|
||||
self.killed = True
|
||||
self.state = tracer.lldb.eStateExited
|
||||
|
||||
class Sink:
|
||||
launched = False
|
||||
close_exit = None
|
||||
|
||||
def mark_launched(self):
|
||||
self.launched = True
|
||||
|
||||
def close(self, expected_exit=False):
|
||||
self.close_exit = expected_exit
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
pid_path = os.path.join(directory, "pid")
|
||||
process = Process()
|
||||
stdout, stderr = Sink(), Sink()
|
||||
|
||||
def acknowledge(config):
|
||||
with open(config["pid_path"], "r") as pid_file:
|
||||
self.assertEqual(pid_file.read(), "12345")
|
||||
return "readable"
|
||||
|
||||
with patch.object(tracer, "_wait_for_identity_ack", acknowledge):
|
||||
exited = tracer._retire_failed_launch(
|
||||
process,
|
||||
{"pid_path": pid_path},
|
||||
object(),
|
||||
stdout,
|
||||
stderr,
|
||||
)
|
||||
|
||||
self.assertTrue(exited)
|
||||
self.assertTrue(process.killed)
|
||||
self.assertTrue(stdout.launched)
|
||||
self.assertTrue(stderr.launched)
|
||||
self.assertTrue(stdout.close_exit)
|
||||
self.assertTrue(stderr.close_exit)
|
||||
|
||||
def test_failed_launch_records_when_valid_process_is_already_exited(self):
|
||||
class Process:
|
||||
def IsValid(self):
|
||||
return True
|
||||
|
||||
def GetProcessID(self):
|
||||
return 12345
|
||||
|
||||
def GetState(self):
|
||||
return tracer.lldb.eStateExited
|
||||
|
||||
def Kill(self):
|
||||
raise AssertionError("an exited process must not be killed")
|
||||
|
||||
class Sink:
|
||||
close_exit = None
|
||||
|
||||
def mark_launched(self):
|
||||
raise AssertionError("an exited process has no output to drain")
|
||||
|
||||
def close(self, expected_exit=False):
|
||||
self.close_exit = expected_exit
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
pid_path = os.path.join(directory, "pid")
|
||||
stdout, stderr = Sink(), Sink()
|
||||
with patch.object(
|
||||
tracer,
|
||||
"_wait_for_identity_ack",
|
||||
side_effect=AssertionError("exit is already observed"),
|
||||
):
|
||||
exited = tracer._retire_failed_launch(
|
||||
Process(), {"pid_path": pid_path}, object(), stdout, stderr
|
||||
)
|
||||
with open(pid_path, "r") as pid_file:
|
||||
self.assertEqual(pid_file.read(), "12345")
|
||||
|
||||
self.assertTrue(exited)
|
||||
self.assertTrue(stdout.close_exit)
|
||||
self.assertTrue(stderr.close_exit)
|
||||
|
||||
def test_pre_target_integrity_failure_reports_no_process_created(self):
|
||||
original_debugger = getattr(tracer.lldb, "SBDebugger", None)
|
||||
|
||||
|
||||
@@ -108,13 +108,6 @@ The `replaced` result is `null`: the successful install response does not say
|
||||
whether the package was installed fresh or replaced, and REA does not query the
|
||||
device first. The install verdict and host APK digest remain available.
|
||||
|
||||
Push and install consume a private snapshot of the selected local input. The
|
||||
reported size and SHA-256 identify those consumed bytes; `local_path` and
|
||||
`apk_path` retain the original input path, whose contents may change later.
|
||||
Snapshot creation needs temporary disk space proportional to the input size.
|
||||
Failed snapshot cleanup remains owned and is retried before later operations
|
||||
and during shutdown.
|
||||
|
||||
## Interpret the result
|
||||
|
||||
- **Directory names retain whitespace and newlines.** Symlink targets do too,
|
||||
@@ -175,9 +168,6 @@ and during shutdown.
|
||||
- Cancellation during a package pull preserves caller-selected output. The
|
||||
error includes partial observations identifying completed artifacts and the
|
||||
interrupted local path; remaining APKs were not attempted.
|
||||
- Screen capture checks cancellation before publishing its exclusive output.
|
||||
If cancellation arrives after publication, the error retains the committed
|
||||
file's path, digest and dimensions; the file remains available as evidence.
|
||||
- Bugreports collect into isolated staging and publish with exclusive creation;
|
||||
filename collisions select the next numeric suffix. If publication fails, the
|
||||
completed archive remains in staging. The error's partial observation gives
|
||||
|
||||
@@ -147,24 +147,6 @@ received signal alone does not establish its exact cause. Dynamic tags require
|
||||
a complete DT_NULL inside PT_DYNAMIC; interpreter names and ranges end at the
|
||||
first NUL, with any padding still represented by the original segment range.
|
||||
|
||||
## Ghidra process failures
|
||||
|
||||
When output from the failing Ghidra startup or operation reports
|
||||
`java.lang.OutOfMemoryError`, REA returns `resource_constraint`. Java heap or GC
|
||||
overhead exhaustion includes heap-specific recovery advice. Metaspace and array
|
||||
size failures do not recommend increasing the heap; native-thread exhaustion is
|
||||
reported as a capacity constraint with unknown limits.
|
||||
|
||||
`configured_jvm_max_heap` records the explicit `-Xmx` value selected by REA's
|
||||
launch builder. It is a configuration fact, not measured memory use or proof of
|
||||
the effective JVM limit; JVM environment options may affect that limit.
|
||||
When a Windows script wrapper selects the JVM, this value remains unknown.
|
||||
Historical stdout and stderr remain available, but classification uses only the
|
||||
failing operation's `failure_output`. Output draining waits at most one second,
|
||||
subject to earlier cancellation or the startup deadline. `output_incomplete`
|
||||
marks a snapshot taken before stream closure; cleanup ownership remains with
|
||||
the session until release succeeds.
|
||||
|
||||
## Portable PE resources
|
||||
|
||||
`inspect_pe_resources` / `inspect-pe-resources` inspects an explicit PE32 or
|
||||
|
||||
@@ -66,25 +66,14 @@ Electron `file://` pages use a separate provider and target boundary; see [elect
|
||||
|
||||
## Provider authorities
|
||||
|
||||
CDP page capture and V8 Inspector observation attach to an already-running
|
||||
target without launching it, driving actions, or evaluating target code.
|
||||
Playwright scenarios drive actions and capture step snapshots in either a
|
||||
provider-owned browser or a caller-selected external browser. Separate providers
|
||||
preserve these authority and lifecycle differences. They share one exclusion
|
||||
vocabulary (`BrowserExclusionReason`): every denial reason maps onto it, even
|
||||
where a wire schema keeps a narrower historical bucket.
|
||||
|
||||
CDP attachment is not a guarantee that the browser preserves all state.
|
||||
Chromium can clear another client's `navigator.platform` emulation when REA's
|
||||
page session disconnects, even if that session sent no emulation commands.
|
||||
This affects page inspection, bundle capture, session observation, screenshots,
|
||||
WebMCP discovery, and Electron page inspection; target listing alone does not
|
||||
attach a page session. REA cannot read the other client's complete
|
||||
user-agent/client-hint configuration and does not replay guessed settings.
|
||||
Use a disposable browser when preserving externally configured emulation is
|
||||
required, or have the owning client reapply its complete configuration afterward.
|
||||
See [the reproduction and Chromium ownership limitation](https://github.com/morluto/rea/issues/4089).
|
||||
|
||||
CDP page capture, V8 Inspector observation, and Playwright scenarios stay
|
||||
separate providers because their authorities differ: CDP and V8 attach to an
|
||||
already-running target and never launch, drive, evaluate, or mutate it, while
|
||||
Playwright providers own and drive the runtime (launch browsers, run actions,
|
||||
capture step snapshots). Merging them would mix attach-only and owned-process
|
||||
lifecycles in one contract. What they share instead is one exclusion
|
||||
vocabulary (`BrowserExclusionReason`): every denial reason in every stack maps
|
||||
onto it, even where a wire schema keeps a narrower historical bucket.
|
||||
Existing static application Evidence and passive web/Electron captures can be
|
||||
combined later through
|
||||
[JavaScript static/runtime reconciliation](javascript-runtime-reconciliation.md).
|
||||
|
||||
@@ -144,15 +144,6 @@ distinction: it closes and deletes provider-owned profiles, but only disconnects
|
||||
from an external CDP browser. Real-browser verification checks both outcomes and
|
||||
confirms that an attached external browser remains alive.
|
||||
|
||||
Keeping that browser alive does not guarantee its emulation state survives.
|
||||
Chromium can clear caller-owned `navigator.platform` emulation when a page CDP
|
||||
session disconnects, including sessions that sent no emulation commands. REA
|
||||
cannot snapshot the other client's complete user-agent/client-hint settings and
|
||||
does not replay a partial reconstruction. Use launch mode to keep this effect
|
||||
inside a provider-owned browser, or have the external owning client reapply its
|
||||
complete configuration after capture. Connected captures report this limitation;
|
||||
see [issue #4089](https://github.com/morluto/rea/issues/4089).
|
||||
|
||||
`environment.locale` sets Intl formatting in both modes. Launch also sets
|
||||
`navigator.language`, `navigator.languages`, and the request `Accept-Language`.
|
||||
Connect preserves the caller's page and request languages; every attached
|
||||
|
||||
@@ -168,12 +168,6 @@ be verified. See [MCP contracts](mcp-contracts.md) for session lifecycle and
|
||||
[Ghidra first-query deadlines](mcp-contracts.md#ghidra-first-query-deadlines-and-recovery)
|
||||
for import, client timeouts and recovery.
|
||||
|
||||
If one-shot analysis fails and closing its session also fails, the original
|
||||
error details remain inline and `details.cleanup_error` describes the later
|
||||
close failure. Each diagnostic retains its own reported resources; the later
|
||||
failure does not establish whether an earlier resource was released. Captured
|
||||
output and partial observations remain in the original details.
|
||||
|
||||
## Save and reuse analysis snapshots
|
||||
|
||||
A snapshot retains successful analysis results for later queries. REA reuses
|
||||
|
||||
@@ -2,12 +2,6 @@
|
||||
|
||||
REA can attach to an Electron/Chromium CDP endpoint and inspect existing `file://` renderer pages without evaluating JavaScript or invoking Electron APIs. The request supplies the endpoint directly; REA accepts only literal-port loopback HTTP endpoints. Selecting an endpoint exposes every Electron target it serves, including local file paths and page metadata.
|
||||
|
||||
Disconnecting the inspection's page session can clear caller-owned
|
||||
`navigator.platform` emulation inside Chromium. REA cannot restore another
|
||||
client's complete user-agent/client-hint configuration. Use a disposable target
|
||||
or let the owning client reapply its configuration; see the shared
|
||||
[CDP state limitation](browser-observation.md#provider-authorities).
|
||||
|
||||
This passive runtime surface is distinct from the target-free static
|
||||
[`analyze_javascript_application`](javascript-artifact-reconstruction.md)
|
||||
workflow. Static analysis reads a local ASAR or extracted directory without
|
||||
|
||||
@@ -139,12 +139,6 @@ overview merely because its source artifact is unchanged.
|
||||
|
||||
## Admitted function-analysis semantics
|
||||
|
||||
Concurrent callers share one startup while retaining independent cancellation.
|
||||
Only the final departing caller abandons startup and waits for its cleanup.
|
||||
New attempts wait for that cleanup; failed cleanup retains its original error
|
||||
and owned directories until a successful close. Closing the provider reports a
|
||||
provider-state failure to live callers rather than cancelling their signals.
|
||||
|
||||
| Concern | Ghidra contract |
|
||||
| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Decompiler lifetime | One persistent `DecompInterface` is opened for the imported Program and disposed during bridge shutdown. Native decompilation has no fixed per-function deadline. External functions or functions without bodies return `null`; cancellation and native failure remain distinct. |
|
||||
|
||||
+2
-9
@@ -39,8 +39,8 @@ container format, architecture, word size and byte order. A recognized
|
||||
- `module.dependencies`, with the same fields and their original order;
|
||||
- `module.settings`, retaining ordered key/value entries and duplicate keys;
|
||||
- `module.unparsed_lines`, `module.unparsed_line_bytes_base64` and
|
||||
`module.complete`, which says whether every present module-text line was
|
||||
parsed. It does not establish that the dependency inventory is complete.
|
||||
`module.complete`, so unfamiliar, malformed, conflicting or undecodable records
|
||||
do not disappear behind a complete result.
|
||||
|
||||
Missing checksums are `null`; empty fields and development/local replacement
|
||||
versions remain unchanged. Build settings such as `GOOS`, `GOARCH` or `vcs.revision`
|
||||
@@ -50,13 +50,6 @@ base64 while other decodable module records are still reported; the reader does
|
||||
not insert replacement characters or reject the entire artifact for those
|
||||
strings.
|
||||
|
||||
When no main-module (`mod`) record was decoded, `module.main` is `null` and
|
||||
dependency coverage is unknown. Successfully decoded dependency records remain
|
||||
visible. GOPATH-mode builds may contain only a package `path` and build settings;
|
||||
their empty dependency array does not establish the absence of dependencies.
|
||||
The result's limitations state this explicitly. A module-mode build with a main
|
||||
module record and no dependency records has an observed empty dependency list.
|
||||
|
||||
## Supported boundary
|
||||
|
||||
The built-in TypeScript reader supports ELF, PE and thin Mach-O images with Go's
|
||||
|
||||
+6
-24
@@ -179,8 +179,6 @@ as well, so it is broader than this Claude-only migration.
|
||||
history under `CLAUDE_CONFIG_DIR`. Setup follows the same
|
||||
variable: it writes the registration to `$CLAUDE_CONFIG_DIR/.claude.json` and
|
||||
the skill to `$CLAUDE_CONFIG_DIR/skills`.
|
||||
For REA setup, an empty `CLAUDE_CONFIG_DIR` is treated as unset: registration
|
||||
goes to `~/.claude.json` and the skill goes to `~/.claude/skills`.
|
||||
|
||||
```bash
|
||||
CLAUDE_CONFIG_DIR=~/.claude-rea npx rea-agents setup --client claude_code
|
||||
@@ -637,11 +635,6 @@ bridge readiness. For large targets, set `REA_HOPPER_STARTUP_TIMEOUT_MS` to a
|
||||
decimal integer from 1 to 2,147,483,647 milliseconds in the environment that
|
||||
starts REA. CLI and MCP use the same setting; invalid values fail configuration
|
||||
validation. An MCP client's own request timeout must also allow enough time.
|
||||
`open_binary` validates and selects a target without waiting for native provider
|
||||
readiness. During Hopper startup, `binary_session.provider_operation_health`
|
||||
reports `busy` at stage `launch`; `analysis_activity` describes bridge requests
|
||||
and can remain idle until the socket is ready. Cleanup work reports `busy` at
|
||||
stage `connection`.
|
||||
|
||||
If macOS denies Apple Events, allow the application that starts REA under
|
||||
**System Settings → Privacy & Security → Automation**, then retry. REA releases
|
||||
@@ -651,12 +644,9 @@ Arguments containing quotes, backslashes, or line breaks remain unchanged but
|
||||
cannot establish that a failed handoff opened no document. Other failed handoffs
|
||||
retain ownership until document closure is confirmed. If a timed-out bridge
|
||||
becomes ready later, `close_binary` connects to that run, authenticates its
|
||||
identity, and requests document shutdown. Once its listener is ready, the bridge
|
||||
allows 30 seconds for the first connection and capability validation. After a
|
||||
connection drops, it allows the same grace period for an authenticated cleanup
|
||||
reconnect, then releases Hopper's Python execution thread. Initial analysis is
|
||||
outside this listener grace period, and authenticated native work is not bounded
|
||||
by it. Expiry does not establish document closure, so REA
|
||||
identity, and requests document shutdown. After a connection drops, the bridge
|
||||
allows 30 seconds for an authenticated cleanup reconnect, then releases Hopper's
|
||||
Python execution thread. Expiry does not establish document closure, so REA
|
||||
retains unconfirmed ownership. Retry close while the bridge remains available.
|
||||
|
||||
If a Linux launcher exists but cannot start, inspect its shared libraries:
|
||||
@@ -746,17 +736,9 @@ Once document and process closure are confirmed, the lease can be released even
|
||||
if temporary-file cleanup fails. Another client can then launch, but the owning
|
||||
client must finish its retained cleanup before starting again.
|
||||
An unconfirmed external document can be retried while its authenticated bridge
|
||||
remains available. The same authentication and process-identity capture apply
|
||||
when the first successful handshake occurs during cleanup after a startup
|
||||
timeout. REA can confirm closure if that exact authenticated process exits,
|
||||
including while a shutdown request is in flight. A helper exit alone is
|
||||
insufficient, and an application that never authenticated has no verified
|
||||
process identity. If no matching bridge becomes available, inspect and close
|
||||
the reported document in Hopper before ending the owning REA connection.
|
||||
Export the Evidence bundle before `close_binary` clears session records.
|
||||
`binary_session.cleanup_pending` remains true while provider cleanup is retained,
|
||||
and provider health remains visible even with `open: false`; that flag alone
|
||||
does not establish successful cleanup.
|
||||
remains connected. If that bridge has disconnected, another close cannot confirm
|
||||
the document: inspect and close the reported document in Hopper before ending
|
||||
the owning REA connection.
|
||||
|
||||
### Hopper in CI
|
||||
|
||||
|
||||
@@ -68,17 +68,6 @@ The node vocabulary covers:
|
||||
- runtime script instance;
|
||||
- an explicit `unknown` kind when classification is not justified.
|
||||
|
||||
Static network endpoints can have `resolution: "partial"` when the analyzer
|
||||
recognizes a request call but cannot resolve its target to one exact value.
|
||||
The observation's `value` then preserves the source expression, and its
|
||||
evidence points to the call site. Partial and exact endpoints have distinct
|
||||
identities even when their displayed values match. Partial identities also retain
|
||||
the source site: matching expression text at different sites does not establish
|
||||
the same runtime target. This records observed source syntax; it does not
|
||||
establish that the call ran or contacted that endpoint.
|
||||
Graph coverage describes the analyzed artifact scope and resource limits, not
|
||||
runtime execution. A partial target alone does not imply omitted source.
|
||||
|
||||
The directed relation vocabulary is `contains`, `loads`, `imports`, `maps_to`,
|
||||
`exposes`, `sends`, `invokes`, `handles`, `calls`, `persists_to`, `observed_as`,
|
||||
and `changed_from`. Provider names are deliberately absent from both
|
||||
|
||||
@@ -95,14 +95,6 @@ matches exactly. Otherwise the result recommends provider-neutral follow-up
|
||||
tools and reports `requires-provider-analysis`; it never starts or switches a
|
||||
provider implicitly.
|
||||
|
||||
A handoff requires the add-on's exact content identity. Unavailable unpacked
|
||||
companions remain visible in the trace graph with their canonical path,
|
||||
availability and container-backed Evidence. They yield no actionable handoff
|
||||
until their bytes are available and the application is reanalyzed; the archive
|
||||
digest does not identify the missing add-on. An empty handoff list does not prove
|
||||
that the trace contains no native components. Source partial coverage remains
|
||||
visible independently of handoff eligibility.
|
||||
|
||||
## Semantic relation tracing
|
||||
|
||||
`trace_javascript_semantics` queries the authenticated companion graph without
|
||||
@@ -125,17 +117,6 @@ registrations/removals and dispatch, Node timers and cancellation handles, async
|
||||
defaults, request construction and response consumers, parse/coercion/
|
||||
validation boundaries, and built-in resource acquisition/release.
|
||||
|
||||
Local callback candidates do not establish a complete target set when a
|
||||
conditional write may leave a parameter, catch binding, or uninitialized
|
||||
variable unchanged. These calls retain candidate edges and dynamic uncertainty;
|
||||
default traces remain ambiguous with partial coverage. Opt into
|
||||
`include_ambiguous_dynamic_edges` to traverse the candidates. Proven preceding
|
||||
unconditional assignments, including writes dominating a read in the same
|
||||
conditional block, can resolve a target; later writes do not replace an
|
||||
earlier read or captured alias. Unproved ordering across branches or function
|
||||
activations remains conservative. Returned-reference effects use the same
|
||||
read-position facts as call resolution.
|
||||
|
||||
Mutation tracking covers explicit member assignments, updates, deletion, and
|
||||
loop assignment targets, including the supported local aliases and shared
|
||||
nested references. Calls conservatively invalidate exposed mutable references;
|
||||
@@ -185,13 +166,8 @@ graph and read literal values from `properties.value`, rather than decoding
|
||||
role keys or labels. Previously stored graphs and their original IDs remain
|
||||
valid inputs.
|
||||
|
||||
Endpoint observations keep their value in `properties.value`. When
|
||||
`properties.resolution` is `partial`, that value is the unresolved source
|
||||
expression, with an identity distinct from an exact endpoint of the same text.
|
||||
Semantic request and response nodes keep their endpoint in `properties.endpoint`. Endpoint
|
||||
lookup identities are preserved independently of the primitive-value lattice's
|
||||
byte budget. An oversized normalized literal can become unknown while the same
|
||||
string remains an exact endpoint for tracing and comparison. Endpoint
|
||||
Endpoint nodes keep the exact endpoint in each observation's `properties.value`;
|
||||
semantic request and response nodes keep it in `properties.endpoint`. Endpoint
|
||||
identity keys use `value-sha256:<digest>` over the canonical JSON string when
|
||||
that is shorter, or when the original value starts with the reserved digest
|
||||
prefix. Other short endpoint keys remain unchanged. Endpoint labels use the
|
||||
@@ -272,13 +248,6 @@ Direct return expressions, including expression-bodied arrows, are evaluated
|
||||
through an execution-free value lattice. Literal object fields and direct
|
||||
return sites are represented in the result. Calls, dynamic spreads, computed
|
||||
keys, and parser recovery remain partial or unknown.
|
||||
Rebound values are evaluated at their read position: saving an incoming parameter
|
||||
before a later assignment preserves caller-dependent uncertainty, while a proven
|
||||
preceding assignment can supply a constant. Unresolved ordering remains unknown.
|
||||
Supported reads within object and array literals follow left-to-right evaluation;
|
||||
an unproved relative order remains unknown. A later write in a separate conditional
|
||||
block can still leave an earlier capture unknown because ordering across those
|
||||
blocks is not proven.
|
||||
Objects and arrays passed to calls, constructors, or tagged templates, used
|
||||
as method receivers, or stored through property targets are not assumed
|
||||
unchanged afterward. Property stores conservatively retain reference escape
|
||||
|
||||
@@ -182,18 +182,6 @@ partial Evidence. Cancellation after source analysis begins can also retain
|
||||
completed facts, including when interrupted during cleanup, graph construction,
|
||||
or Evidence sealing. Unexamined relationships remain unknown.
|
||||
|
||||
Per-file gaps identify the applicable processing phase: JavaScript source analysis
|
||||
uses AST authority, while package/JSON, HTML-reference and source-map processing
|
||||
use artifact-byte authority. File-analysis interruption gaps carry `analysis_status`:
|
||||
`interrupted` means the phase was entered (including source-worker startup),
|
||||
and `not-started` means interruption prevented that phase from beginning.
|
||||
Neither state establishes that parsing completed. Remaining parsers are not run
|
||||
after interruption just to populate a result.
|
||||
|
||||
Native add-ons remain metadata-only and acquire no JavaScript parse or analysis
|
||||
gap. This also applies when their paths are outside `source_paths`; their inventory
|
||||
and caller selection remain available without implying applicable AST work.
|
||||
|
||||
MCP returns a `partial_observation` retained reference after recording succeeds;
|
||||
open it with `inspect_analysis_view` on the same connection. If the SDK stopped
|
||||
waiting before receiving the reply, follow [MCP cancellation recovery](mcp-contracts.md#progress-and-cancellation)
|
||||
@@ -311,25 +299,13 @@ suffix. Utility calls such as `useUtils().invoice.list.fetch()`, `useQueries`,
|
||||
and links whose callee was renamed by a minifier are not recognized.
|
||||
|
||||
Each recovered bundle module retains the exact factory-source digest. A complete
|
||||
bounded AST also receives a `babel-ast-v3` structural fingerprint. It ignores
|
||||
ordinary identifier spellings while retaining literal and directive values,
|
||||
operators, fixed property names, and selected syntax flags such as computed
|
||||
keys, declaration kind, function async/generator state, update-expression
|
||||
prefix, method kind, and class static state. Local names used in computed keys
|
||||
remain rename-resistant; private member names are also ignored while their
|
||||
method kind and static state remain represented.
|
||||
|
||||
This fingerprint is structural evidence for candidate matching, not proof that
|
||||
two modules behave equivalently. Its scope follows the AST facts listed above;
|
||||
unrepresented syntax can still collide. The exact source digest remains
|
||||
available to show byte-level change, and comparison reports content changes even
|
||||
when structural matching succeeds.
|
||||
|
||||
Version comparison includes the algorithm in its structural matching key.
|
||||
Retained `babel-ast-v1` results can still match other v1 results, and v2 results
|
||||
can still match v2 results, but v1/v2 results cannot structurally match v3
|
||||
results. Other matching tiers remain available across algorithm versions.
|
||||
Re-analyze both snapshots to compare using the v3 rules.
|
||||
bounded AST also receives a `babel-ast-v2` structural fingerprint that ignores
|
||||
ordinary identifier names while retaining syntax, literals, operators, object
|
||||
keys, and member properties. Computed member identifiers retain their access
|
||||
syntax without treating a local variable's spelling as a fixed property; template
|
||||
literal contents remain part of the fingerprint. Version comparison keeps the
|
||||
algorithm in its matching key, so retained `babel-ast-v1` fingerprints cannot match
|
||||
these new fingerprints. Re-analyze both snapshots to compare their new structure.
|
||||
If fingerprint construction reaches its structural
|
||||
bound, the fingerprint is unavailable and its status is `truncated`; a bounded
|
||||
prefix is never presented as a complete stable fingerprint.
|
||||
@@ -426,13 +402,10 @@ For `.node` bindings, member names mean “requested by JavaScript syntax.” A
|
||||
resolved add-on path does not convert them into verified native exports. Native
|
||||
symbol verification remains a separate deep-analysis claim.
|
||||
|
||||
Exact endpoint values preserve useful local diagnostics, including query values
|
||||
and fragments, while removing URL username/password credentials when the value
|
||||
parses as a URL. When a recognized request target cannot be resolved exactly,
|
||||
the endpoint's partial resolution retains the original source expression with
|
||||
its call-site provenance. This does not establish that the request executed.
|
||||
Artifact paths, digests, parse locations, and analysis metadata remain
|
||||
actionable because REA is local-only.
|
||||
Endpoint observations preserve useful local diagnostics, including query values
|
||||
and fragments, while removing only URL username/password credentials. Artifact
|
||||
paths, digests, parse locations, and analysis metadata remain actionable
|
||||
because REA is local-only.
|
||||
|
||||
## Safety boundary
|
||||
|
||||
@@ -464,18 +437,7 @@ retained candidate strings and temporary canonical-key serialization. This is
|
||||
an in-memory semantic allocation bound independent of CLI or MCP transport
|
||||
budgets. Source literal bytes remain in the parsed source and artifact evidence;
|
||||
when a normalized semantic value exceeds the bound, its value is unknown and
|
||||
coverage is partial. Direct string literals, cooked templates without
|
||||
substitutions, and derived strings all use this normalization boundary. A
|
||||
single exact primitive is validated without allocating deduplication or sort
|
||||
state or serializing a canonical key. Configuration defaults use the same
|
||||
normalizer; limited defaults retain `value_resource_limit` and an anchored
|
||||
resource-limit unknown. Known null, false, zero, and empty-string defaults stay
|
||||
exact. This primitive-value bound does not truncate lookup identities such as
|
||||
source paths, field names or request endpoints. Full endpoint properties remain
|
||||
available for endpoint queries, tracing and comparison. Each analysis records encountered limit classifications independently of
|
||||
later projections: a selected healthy sibling can remain exact while whole-file
|
||||
coverage reports the encountered bound. Projection preserves limiting values
|
||||
from the shared property-slot owner. Expression
|
||||
coverage is partial. Expression
|
||||
evaluation and provenance walks stop after 256 nested levels. Union products
|
||||
and string lengths are checked before allocating combinations or concatenated
|
||||
strings. When a boundary is reached, the value stays unknown, semantic coverage
|
||||
|
||||
@@ -48,7 +48,6 @@ The first text or assembly request in a session looks for this target's export i
|
||||
- REA starts `kuna decompile-project` in the background on a private copy of the target.
|
||||
- Meanwhile, pseudocode comes from one `kuna decompile --addr` run. Name and address lookups, and listings, use the inventory the export takes with `kuna functions --json` before it decompiles. The session runs `kuna functions` itself, under `REA_KUNA_TIMEOUT_MS`, only when no export is building (an inventory-only request does not start one) or the export ends without an inventory.
|
||||
- Requests for the same function share one run; it stops when its last waiting request is cancelled. Each run analyzes the whole image again in its own process, so one REA process runs at most as many at once as the host has cores beyond `REA_KUNA_JOBS` (at least one). Further requests wait in order, and a waiting request is answered from the export if it finishes first. A run whose stop REA cannot prove keeps its slot until `close_binary` proves it stopped.
|
||||
- The session keeps each completed single-function text, up to 16 MiB in all with the least recently used dropped first, and answers repeats from it until the export can. After a failed export that lasts for the session.
|
||||
- Assembly and data names wait for the export; progress notifications report the wait every ten seconds. A session does not rebuild a failed export: requests that need it fail with `retryable: false`, the export's failure, its captured Kuna output and what to change before reopening the target. A setting such as `REA_KUNA_PROJECT_TIMEOUT_MS` or `REA_KUNA_JOBS` is read when REA starts, so changing it also needs a restart. Pseudocode keeps using single-function runs.
|
||||
- A single-function answer says so in its limitations. It lacks the export's whole-program prototypes, so a later request can return different text for the same function.
|
||||
|
||||
|
||||
+3
-32
@@ -393,26 +393,15 @@ concrete version, selection source, and complete analysis profile through
|
||||
choices return typed selection details. A selected provider is never replaced
|
||||
automatically after a runtime failure.
|
||||
|
||||
Each provider client receives `binary_session.analysis_run.run_id` before any
|
||||
provider startup, including clients whose startup fails. `process_lineage` is
|
||||
`not_observed` until a dynamic provider starts, then becomes `snapshots` with
|
||||
every started provider's identity
|
||||
Every successful target transition allocates `binary_session.analysis_run.run_id`
|
||||
before any provider startup. `process_lineage` is `not_observed` until a dynamic
|
||||
provider starts, then becomes `snapshots` with every started provider's identity
|
||||
and retained ownership observation. Each observation records `observed_at` and
|
||||
is `unavailable` with a reason when ownership could not be revalidated, or
|
||||
`verified` with launcher PID, parent PID, process group, and descendants observed
|
||||
at that bounded check. These are historical snapshots, not live process
|
||||
inventories, and do not claim that no short-lived descendant existed.
|
||||
|
||||
`binary_session.cleanup_pending` reports whether the session retains a provider
|
||||
client, session file resource, or provider-candidate resource whose cleanup has
|
||||
not succeeded. It can be true with `open: false`; target retirement does not
|
||||
establish resource release. Health, activity, and lineage remain available
|
||||
under a retained client's original `analysis_run.run_id` where the provider
|
||||
supplies them. Successful client cleanup clears the retained run; a replacement
|
||||
client receives a fresh run ID. Follow the cleanup error's reported resources
|
||||
and recovery action before reopening; a missing health observation does not
|
||||
establish an idle provider.
|
||||
|
||||
## Progress and cancellation
|
||||
|
||||
REA accepts ordinary `tools/call` progress tokens. The numeric `progress` counts
|
||||
@@ -439,10 +428,6 @@ Native call tracing and process capture retain available observations in
|
||||
`details.partial_observation` on failure, including when cleanup succeeds.
|
||||
The observation reports its partial coverage; cleanup details describe host
|
||||
state separately from the execution failure.
|
||||
For these tools, cancellation observed during result finalization or owned
|
||||
cleanup also returns typed cancellation with the available observations.
|
||||
A normal target exit does not establish request completion. Incomplete cleanup
|
||||
still takes precedence and retains its resource diagnostics.
|
||||
A process capture that fails during a finalization interval keeps every signal
|
||||
attempt and its delivery result in `details.partial_observation`, with
|
||||
`elapsed_ms` and `exit_code` null when no exit was observed.
|
||||
@@ -709,20 +694,6 @@ after SDK conversion and check advertised validation and actual calls.
|
||||
Individual model APIs can impose additional nesting limits; complete producer
|
||||
captures can exceed ten structural levels.
|
||||
|
||||
Boolean literal constraints in input schemas are relaxed only in this
|
||||
advertisement. For example, a boolean `const` is presented as `type: boolean`;
|
||||
an affected `not` is omitted, conditional predicates and their branches are
|
||||
omitted together, pure boolean-literal `oneOf` branches collapse to a boolean,
|
||||
and other affected `oneOf` branches are presented as `anyOf` to retain branch
|
||||
guidance without making overlapping widened branches reject inputs.
|
||||
This can make the advertised schema accept inputs the canonical contract
|
||||
rejects. The MCP handler still validates every call with the canonical
|
||||
contract. The Gemini CLI verifier checks the outgoing
|
||||
`parametersJsonSchema` and canonical contract examples against that declaration
|
||||
using a loopback model fixture; it does not establish live Google API or
|
||||
OpenCode client behavior. Set `REA_VERIFY_GEMINI_SCHEMA_PROFILE=compact` to
|
||||
verify the compact advertisement through the same client boundary.
|
||||
|
||||
### Compact input schema profile
|
||||
|
||||
Some function-calling providers reject a request while any single tool's
|
||||
|
||||
@@ -451,11 +451,6 @@ The run ends when the process exits, `max_events` entries are recorded,
|
||||
Bounded termination reports partial coverage. REA checks process termination
|
||||
using a launch-time OS start identity; if ownership or cleanup cannot be
|
||||
verified, the result or error preserves that uncertainty. The result reports:
|
||||
Launch errors keep the fact that LLDB created a process separate from whether
|
||||
it remains alive. An exited `SBProcess` is reported as exited only after LLDB
|
||||
confirms that state; unresolved ownership remains retained for cleanup retry.
|
||||
Cancellation observed while output and Evidence are finalized returns partial
|
||||
cancellation Evidence, even if the target has already exited.
|
||||
|
||||
- the outcome, exit status and captured stdout/stderr (1 MiB kept per stream
|
||||
while excess bytes are drained and counted without growing capture files).
|
||||
@@ -486,11 +481,6 @@ with partial coverage. Available output prefixes remain inline; their byte
|
||||
counts are observed lower bounds when final drain counters are unavailable.
|
||||
The original failure classification and cleanup uncertainty remain separate.
|
||||
An interrupted journal row is ignored with an explicit limitation.
|
||||
If the trace completed before cancellation or runtime-directory cleanup failed,
|
||||
the retained observation also keeps its exit status, termination proof, launch
|
||||
identity, breakpoint results and final stream counters. Those fields remain
|
||||
absent when the interrupted producer did not report them; partial coverage alone
|
||||
does not mean that every retained fact is incomplete.
|
||||
|
||||
Only entries are observed: return values, floating-point and stack arguments,
|
||||
and inlined or `objc_direct` calls are not. The target runs with the current
|
||||
@@ -587,18 +577,6 @@ Exact and ambiguous value counts describe emitted root/object value instances;
|
||||
a root and an object may contain the same value. Archive digests identify the
|
||||
original bytes.
|
||||
|
||||
Interface Builder's XML and binary plist archives use the same number metadata
|
||||
and exact-decimal representation for emitted node attributes. Projection follows
|
||||
object and connection classification, so archive IDs, UID links and graph counts
|
||||
keep their meaning. Precision limitations name the source document. Unsafe
|
||||
integer-literal counts cover the archive, including fields not emitted as node
|
||||
attributes; exact and ambiguous projection counts cover emitted attribute values.
|
||||
Integral reals stay numbers, and ambiguous or incompletely observed values retain
|
||||
explicit precision limitations. Before plist decoding, the existing aggregate
|
||||
decode budget reserves estimated room for number metadata and attribute
|
||||
projection; these estimates are not a hard process-memory bound. Native
|
||||
NIBArchive decoding is unchanged by this plist-specific representation.
|
||||
|
||||
Dates are reported as `{ "$plist_type": "date", "iso8601": "<timestamp>" }`. A
|
||||
date the decoder cannot represent, such as an XML date with a year beyond 9999
|
||||
or a negative year, is reported as `{ "$plist_type": "date", "iso8601": null }`
|
||||
|
||||
@@ -425,9 +425,7 @@ results for unaffected dimensions and mark affected dimensions unknown; an
|
||||
incomplete capture cannot locate the first divergence across all dimensions.
|
||||
Trace assertions use coverage for the sources they select, so an assertion
|
||||
about complete raw terminal output need not fail because rendered snapshots
|
||||
were omitted. A trace difference applies to the dimensions identified by its
|
||||
diagnostic; unrelated dimensions retain their own comparison, including unknown
|
||||
coverage. Captures missing `truncation_details` are rejected on import;
|
||||
were omitted. Captures missing `truncation_details` are rejected on import;
|
||||
preserve them as historical files and recapture for current comparisons.
|
||||
`limits.file_bytes` is already the cumulative whole-file hashing budget,
|
||||
independent of `limits.output_bytes`, which bounds retained terminal content.
|
||||
|
||||
@@ -105,20 +105,6 @@ overall native heap and total resident memory are not capped. Row limits do not
|
||||
override these byte and resource limits. Resource-limit failures do not return
|
||||
an incomplete schema as successful complete evidence.
|
||||
|
||||
If the combined database and WAL exceed the snapshot budget, the refusal is a
|
||||
`resource_constraint` and reports both the configured byte limit and the exact
|
||||
observed combined size as a decimal string. The remediation directs callers to
|
||||
create a smaller consistent offline snapshot containing only relevant data
|
||||
through the application's supported export workflow. A generic backup or copy
|
||||
does not guarantee a smaller result; REA does not truncate or modify the
|
||||
selected source.
|
||||
|
||||
On hosts that cannot address the derived WAL or rollback-journal path for a
|
||||
long selected database name, REA reports that the SQLite capability is
|
||||
unavailable. It does not assume an inaccessible sidecar is absent. Use the
|
||||
application's supported consistent offline export or copy workflow to place
|
||||
the complete known file set at a shorter path.
|
||||
|
||||
MCP also applies its configured response budget to the complete Evidence
|
||||
envelope. If delivery exceeds that budget, it reports a transport constraint
|
||||
with guidance for exporting retained Evidence, requesting a matching larger
|
||||
|
||||
+1
-51
@@ -199,44 +199,6 @@ Measure slow cases before pruning capacity coverage. Retain inputs beyond the
|
||||
formerly failing size/depth and distinguish cold runs, warm builds, coverage,
|
||||
and toolchain conditions when comparing timings.
|
||||
|
||||
## Lifecycle regressions
|
||||
|
||||
For changes to resource acquisition, readiness, cancellation, or cleanup, select
|
||||
the affected owners and applicable scenarios below. Include temporary snapshots
|
||||
and one-shot commands. Use public CLI/MCP workflows where practical and a
|
||||
controlled production seam for interleavings that cannot be reproduced reliably.
|
||||
|
||||
| Scenario | Assertion and control |
|
||||
| --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|
||||
| Target admitted; startup still pending | Status preserves the readiness distinction and observed startup activity; readiness requires the provider's documented proof. |
|
||||
| First handshake is late, absent, invalid, or recovered during close | Initial and recovery paths retain the same authenticated identity facts. Foreign run/token controls cannot authorize cleanup; authenticated idle/native work survives the unauthenticated listener deadline. |
|
||||
| Launch returns an error with a valid process handle | Cover already-exited and still-live owned processes. Verify observed exit separately from creation; failed termination or unavailable identity remains unresolved. |
|
||||
| Cancellation arrives after workload exit, during result reads or temporary-root removal | Return typed cancellation with available partial observations and actual cleanup status. The non-aborted control succeeds; existing primary/cleanup failures keep their precedence. |
|
||||
| Children have mixed health or cleanup outcomes | Missing peer health does not erase an observed failure or activity. Idle plus unknown stays unknown. Retry a failed child without closing a successful peer again, including after a close-option change. |
|
||||
| Cleanup fails after success or primary failure | Public output retains the completed observation or primary diagnostic, remaining resources, and owner recovery action. Restore the denied resource and verify the owning cleanup retry. |
|
||||
| Target exits without an acknowledgement, or transport disappears while it stays alive | Positive owned exit proof resolves target lifetime; other resources still need cleanup. Lost transport alone does not prove exit. Verify unrelated/attached targets survive and same-connection recovery works when supported. |
|
||||
|
||||
Synchronize cancellation with the finalization boundary being tested; a fixed
|
||||
delay after dispatch does not establish that phase. Use markers, barriers, or
|
||||
owned cleanup seams while preserving real cleanup where feasible. Check server
|
||||
settlement and retained resources even if the MCP SDK rejects the client promise
|
||||
before the handler finishes. A cancellation during active execution does not
|
||||
cover cancellation during final cleanup.
|
||||
|
||||
For atomic writes, exercise cancellation on both sides of the documented commit
|
||||
point and preserve any publication receipt. A late interruption does not prove
|
||||
that no output was published.
|
||||
|
||||
Representative regressions include
|
||||
[process cleanup-time SIGINT](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/process/processCaptureCancellationAdapters.test.ts),
|
||||
[late authenticated cleanup](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/providers/hopper/hopperClient.handshakeRecovery.test.ts),
|
||||
[LLDB launch and finalization](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/providers/native/lldbCallTracerFailures.test.ts),
|
||||
[composed child ownership](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/src/application/binary/CompositeProvider.test.ts),
|
||||
and [public CLI cleanup denial](https://github.com/morluto/rea/blob/e78455338fe2d06c4cd03d59cbf33473d754998b/tests/boundary/cli/wasmCleanupCli.test.ts).
|
||||
These controlled probes do not replace the matching real-provider lane. Record
|
||||
the base failure, passing control, exact host/provider, verified cleanup, and
|
||||
unavailable coverage; a missing engine is not a pass.
|
||||
|
||||
## Behavioral depths
|
||||
|
||||
| Depth | Location | What it proves |
|
||||
@@ -1027,19 +989,7 @@ the Apple or Windows curated lanes invoke explicitly, which also select that
|
||||
lane. Edits to verifier entrypoints run only by manual, licensed or self-hosted
|
||||
workflows run static checks and the Linux suite. Website changes run website
|
||||
checks. Provider workflow changes validate the workflow and run that provider's
|
||||
verifier. Changes under `bridge/ghidra/` also select the `ghidra_bridge` lane,
|
||||
which compiles the packaged bridge sources against the pinned Ghidra 12.1.4
|
||||
jars with `npm run verify:ghidra:bridge-sources`. It never launches Ghidra or
|
||||
imports a target, so a missing import fails the PR instead of every Ghidra
|
||||
session. The launcher, compiler and package checks share named required source
|
||||
roles. The manifest must match the complete Java cohort, so deleting a helper
|
||||
or adding an unregistered dependency cannot silently change the shipped set.
|
||||
The preflight reuses the provider's Java Properties parser with the pinned Node
|
||||
toolchain's native type stripping, without an npm install or runtime build.
|
||||
The shared release policy owns the verified version and JDK major. CI checks
|
||||
the archive pin before downloading and verifies the extracted SDK version;
|
||||
changes to these source owners also select the compile lane.
|
||||
Manual-provider/Android workflow changes run workflow validation only.
|
||||
verifier. Manual-provider/Android workflow changes run workflow validation only.
|
||||
The four-version SQLite compatibility matrix has its own `sqlite` scope for
|
||||
SQLite implementation, contracts, CLI/MCP registration, fixtures, and shared
|
||||
runtime boundaries. SQLite and server-lifecycle test edits and the SQLite npm
|
||||
|
||||
@@ -68,54 +68,6 @@ satisfy. A plan without execution does not establish runtime behavior.
|
||||
constraints. Report pagination, truncation, cancellation, and partial failure.
|
||||
An assumed agent budget is insufficient justification for a limit.
|
||||
|
||||
## Own the lifecycle
|
||||
|
||||
For tools that acquire resources, identify the owner and the observations that
|
||||
establish each transition. Include temporary files and one-shot commands, as
|
||||
well as persistent engine sessions. Use the existing provider contracts;
|
||||
providers need not expose identical state machines.
|
||||
|
||||
- Keep target admission, provider readiness, active work, observed process exit,
|
||||
and resource release separate. A valid process handle, successful launcher,
|
||||
or selected target establishes only its own fact. Publish available identity
|
||||
and exit observations even when launch fails; retain unknown ownership.
|
||||
- Authenticate and capture identity through the same boundary on initial and
|
||||
recovery handshakes. Bound abandoned unauthenticated listeners where the
|
||||
protocol permits it; that deadline must not expire authenticated idle sessions
|
||||
or long-running native work. Listener expiry does not prove target closure.
|
||||
- Shared startup has one producer and independently cancellable caller waits.
|
||||
Keep it running while any caller still needs it. The final departing caller
|
||||
waits for owned cleanup and retains its failure. Provider closure is distinct
|
||||
from caller cancellation. Retained cleanup capabilities block replacement;
|
||||
derive readiness from the current startup's completion and live connection.
|
||||
- For cancellable observations, carry cancellation through result consumption
|
||||
and awaited cleanup. Before returning success, check the signal after the
|
||||
last awaited finalization step.
|
||||
Retain collected observations under typed cancellation. Preserve an existing
|
||||
primary failure and let incomplete cleanup retain its own classification.
|
||||
Client cancellation alone does not prove native work stopped.
|
||||
For atomic publication, document the cancellation cutoff and preserve any
|
||||
committed output's publication receipt.
|
||||
- Release only owned resources. Attaching owns a connection or session unless
|
||||
the provider contract explicitly establishes target ownership. A helper exit,
|
||||
missing reply, or missing PID does not establish target exit.
|
||||
- Retain successful child cleanup and retry only unresolved children, including
|
||||
when close options change. Preserve observed child failure or activity when
|
||||
another child's health is unavailable; idle plus missing coverage stays
|
||||
unknown.
|
||||
Bind cleanup failures to their exact resource owner. Resolve current cleanup
|
||||
uncertainty only after that owner confirms release, while preserving the
|
||||
original failure and completed observations. Later failure composition must
|
||||
report only resources whose cleanup remains unresolved.
|
||||
- Await one-shot cleanup without discarding the completed result or primary
|
||||
diagnostic. Preserve partial observations, remaining resources, and the cleanup
|
||||
owner's recovery instructions. CLI adapters should reuse
|
||||
[`finishAnalysisCommand`](https://github.com/morluto/rea/blob/main/src/cli/finishAnalysisCommand.ts) where its contract
|
||||
applies rather than duplicate close/finally handling.
|
||||
|
||||
Exercise the applicable [lifecycle regression scenarios](testing.md#lifecycle-regressions)
|
||||
through the producing owner and affected CLI/MCP consumers.
|
||||
|
||||
## Implement and evaluate
|
||||
|
||||
Put provider protocols/parsing in adapters and shared CLI/MCP workflows in the
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,245 +0,0 @@
|
||||
# Interrupted application processing: applicability and Evidence
|
||||
|
||||
Tracks #3948 under #4027. Measured baseline:
|
||||
`c7f6b8bad1a34d5efb30ff2a017672dea1fcdabb`.
|
||||
|
||||
The question is which processing phases remain unavailable after a source
|
||||
interruption, while keeping native inventory and already collected facts.
|
||||
Native identity and provider linkage must stay independent of application-wide
|
||||
partial coverage. This is static artifact analysis; no target application or
|
||||
native provider runs.
|
||||
|
||||
## Observed failure and correction
|
||||
|
||||
The interruption producer previously attached one generic failure to every
|
||||
remaining relevant file. Graph projection interpreted it as JavaScript AST work.
|
||||
Real Joplin reproduced an `analyze-javascript-source` / `ast-static-analysis`
|
||||
unavailable scope on keytar's native binary and on unvisited package, HTML and
|
||||
source-map files. Public CLI/MCP controls reproduced the same applicability
|
||||
problem. Deterministic cancellation before native metadata additionally produced
|
||||
a phantom JavaScript semantic module for the binary.
|
||||
|
||||
The producer now records the applicable operation/authority and whether the
|
||||
phase was entered. `analysis_status: interrupted` includes worker startup and
|
||||
does not imply parsing completed; `not-started` identifies unvisited phases.
|
||||
Native add-ons need no post-inventory source-processing phase, so neither interrupted
|
||||
nor caller-excluded native files acquire AST scopes or semantic modules.
|
||||
Actual JavaScript failures, structured-file unknowns, caller selection and byte
|
||||
identity remain available. The graph consumes these produced facts.
|
||||
|
||||
The AST-only unavailable Evidence helper is replaced by an explicitly typed
|
||||
static helper. Normal package/JSON/map gaps also retain their artifact-byte
|
||||
authority. Per-file progress uses the same applicability owner: JavaScript keeps
|
||||
its source phase, and metadata uses `process_javascript_artifact_metadata`.
|
||||
Remaining parsers do not run after interruption. Failure sharing is limited to
|
||||
five applicable phases during one interruption; no persistent cache is added.
|
||||
|
||||
A second review found the alternate full-analysis semantic builder still
|
||||
created modules for every excluded file kind. An actual filesystem-producer
|
||||
regression on revision `323fae8cbf3e36677bcb7b22ba31fa1a7e3c5cd4` reproduced
|
||||
phantom native/JSON/HTML/package/source-map modules, while selected and excluded
|
||||
JavaScript were positive controls. Semantic applicability now belongs to the
|
||||
shared `recordUnavailableFile` projection entry point, before retaining limits,
|
||||
nodes, roots or unknowns. Three duplicate caller checks are removed. Both full
|
||||
and incremental construction use this boundary; actual excluded JavaScript
|
||||
continues to carry source-bound unknowns and partial semantic coverage.
|
||||
|
||||
## Real input and reproduction
|
||||
|
||||
Use the [official Joplin v3.7.21 acquisition and extraction instructions](https://github.com/morluto/rea/blob/c7f6b8bad1a34d5efb30ff2a017672dea1fcdabb/docs/verification/javascript-native-handoff-identity-2026-10-15.md).
|
||||
The AppImage SHA-256 is
|
||||
`5d202dcaca31e14206826aa3f04125e7c218dbc3dc3d98479d811efbd6b856c1`;
|
||||
ASAR SHA-256 is
|
||||
`767df409b18effe60421fbefcca873de237c7e813eac744ecdeebbc5e825a33a`.
|
||||
The 6,324-file inventory includes 46 unpacked entries. Both cohorts stage all
|
||||
three native companions; the other 43 unpacked entries remain unavailable.
|
||||
|
||||
Build with pinned Node 24.18.0/npm 11.16.0 and locked dependencies. The extended
|
||||
existing verifier also runs against the baseline runtime; copy the verifier and
|
||||
`scripts/lib/javascript-file-scope-oracle.mjs` from the fixed revision into a
|
||||
built baseline checkout when reproducing the failure.
|
||||
|
||||
```bash
|
||||
artifact_path="/absolute/path/to/cases/available/app.asar"
|
||||
common=(
|
||||
--artifact "$artifact_path"
|
||||
--addon-path node_modules/keytar/build/Release/keytar.node
|
||||
--native-sha256 0700016bcd761cbe02d275f2046c7cc42f39f730a50d66e3d3307aa9d413373a
|
||||
--source-path ElectronAppWrapper.js
|
||||
--source-path ElectronAppWrapper.js.map
|
||||
--source-path index.html
|
||||
--source-path package.json
|
||||
--source-path node_modules/keytar/build/Release/keytar.node
|
||||
--structured-path ElectronAppWrapper.js.map
|
||||
--structured-path index.html
|
||||
--structured-path package.json
|
||||
--structured-expectations '{"ElectronAppWrapper.js.map":{"operation":"parse-local-source-map","analysis_status":"not-started"},"index.html":{"operation":"parse-html-script-references","analysis_status":"not-started"},"package.json":{"operation":"parse-package-json","analysis_status":"not-started"}}'
|
||||
--rounds 3 --cli-parity
|
||||
--tokenizer-python /absolute/path/to/python-with-tiktoken-0.12.0
|
||||
)
|
||||
node scripts/verify/javascript/native-handoffs.mjs "${common[@]}" \
|
||||
--analysis-timeout-ms 1 --expect-timeout --require-safe
|
||||
node scripts/verify/javascript/native-handoffs.mjs "${common[@]}" \
|
||||
--validate-structured-from-export --require-safe
|
||||
```
|
||||
|
||||
Omit `--require-safe` on the baseline timeout run to record its incorrect
|
||||
applicability. Its diagnostic exit 0 is not a passing analyst task. A supported
|
||||
1 ms deadline includes worker startup; the verifier requires a typed timeout
|
||||
and retained partial reference for that cohort. Each structured path supplies an
|
||||
independent expected operation and phase-entry status; the safety oracle matches
|
||||
all gaps exactly, including unavailable state and unknown confidence. Missing or
|
||||
conflicting expectations do not pass.
|
||||
|
||||
The native path is explicitly selected. An earlier structured-only run excluded
|
||||
it and therefore did not reproduce the native interruption. Input selections
|
||||
and that preliminary result remain recorded. Both final cohorts preserve
|
||||
partial coverage for unselected/unavailable scopes.
|
||||
|
||||
The supplied native Evidence is simulated solely to check exact subject linkage.
|
||||
The verifier checks physical companion bytes and the exported parent's root
|
||||
digest, validates public CLI/MCP native-trace parity, and reports only after
|
||||
owned transport/command/private-file cleanup. Applications and large Evidence
|
||||
are regenerable and are not archived.
|
||||
|
||||
## Two distinct task projections
|
||||
|
||||
The **timeout task** includes the expected typed-timeout preparation, one inline
|
||||
native trace and three inline structured-path traces. It checks that native has
|
||||
no AST failure and that each unvisited structured phase remains unavailable with
|
||||
the appropriate artifact-byte authority and `not-started` status.
|
||||
|
||||
The **default-deadline control** models the summary plus one inline native trace.
|
||||
Its named structured paths are additionally validated from the already exported
|
||||
complete parent, explicitly labelled `exported-parent-validation`. Those checks
|
||||
are diagnostic overhead outside the modeled native-task tokens and inside total
|
||||
verifier resources. They are not presented as inline metadata answers.
|
||||
|
||||
A control that also requested the complete outgoing `package.json` feature trace
|
||||
hit stdio admission twice: at least 10,587,373 bytes against a 10,484,736-byte
|
||||
result budget, with identical retained parent/trace identities. It is not a
|
||||
completed equivalent task or an efficiency baseline. [#4190](https://github.com/morluto/rea/issues/4190)
|
||||
records the separate need for exact retained metadata/native fact views. Complete
|
||||
export remains available. Do not compare costs across these different tasks.
|
||||
|
||||
## Measurements
|
||||
|
||||
| Cohort | Revision | Wall s | CPU s | Peak cgroup bytes | Applicability |
|
||||
| ------------------------------ | -------- | ------: | ---------: | ----------------: | ------------- |
|
||||
| Timeout, four inline traces | baseline | 60.738 | 60.289464 | 3,092,045,824 | wrong scope |
|
||||
| Timeout, four inline traces | final | 57.515 | 57.089883 | 2,763,276,288 | pass |
|
||||
| Default control, native inline | baseline | 61.542 | 61.135522 | 2,808,336,384 | pass |
|
||||
| Default control, native inline | final | 186.085 | 142.371100 | 2,959,585,280 | pass |
|
||||
|
||||
| Defined task | Selected catalog + parsed/structured replies BPE | Selected catalog + complete tool replies BPE |
|
||||
| -------------- | -----------------------------------------------: | -------------------------------------------: |
|
||||
| Timeout | 21,136 → 20,161 | 36,468 → 34,471 |
|
||||
| Native control | 11,776 → 11,720 | 17,738 → 17,632 |
|
||||
|
||||
The full-catalog alternatives and per-query samples are preserved in JSON.
|
||||
Native content identity, observed byte provenance, source selection and handoff
|
||||
provider Evidence remain equal. Corrected global provenance changes derived
|
||||
parent/trace identities; null partial-Evidence subjects remain null. Both final
|
||||
runs have exact CLI/MCP native-trace parity and match the earlier post-fix
|
||||
controls in every recorded non-timing field.
|
||||
|
||||
The whole verifier includes input hashing, analysis, three native trace rounds,
|
||||
applicable structured queries, export, CLI parity and tokenization. Every heavy
|
||||
run uses the preserved [resource observer](https://github.com/morluto/rea/blob/b3bdabab694af1f9801eff7caf75001b92314a58/experiments/analysis-efficiency/resource-run.py):
|
||||
one CPU, 8 GiB hard cap, 6 GiB early stop and no swap. Cgroup peaks include charged
|
||||
file cache, not summed RSS. Counters are observed at payload exit while the
|
||||
observer remains alive, not final whole-scope counters. Completed runs verify
|
||||
owned cleanup and report no OOM.
|
||||
|
||||
Each MCP process is fresh, but input hashing warms its file cache. Build/OS caches
|
||||
and shared-host scheduling are uncontrolled. First and repeated retained-query
|
||||
wall samples remain separate; isolated query CPU/memory are unmeasured. An
|
||||
earlier fixed timeout took 150.173 s wall / 119.468013 s CPU; its exact unchanged
|
||||
runtime repeat took 58.827 s / 58.482996 s, with identical non-timing facts,
|
||||
Evidence and BPE. Both receipts are retained. The final default control also took 186.085 s wall / 142.371100 s CPU; its
|
||||
unchanged-runtime repeat took 62.651 s / 62.240964 s with identical non-timing
|
||||
results. The slow final row remains reported. Attribution remains unresolved;
|
||||
these runs establish no speedup or performance-equivalence bound.
|
||||
|
||||
The stricter post-review verifier reruns also passed without changing production
|
||||
code: timeout 162.645 s wall / 125.876114 s CPU / 2,809,643,008 B peak; default
|
||||
control 61.367 s / 60.970077 s / 2,526,949,376 B. Both preserve the original final
|
||||
analytical fields, identities, coverage and BPE exactly; only timings and the new
|
||||
explicit oracle-input field differ. These additional receipts do not replace the
|
||||
slower rows above.
|
||||
|
||||
After centralizing semantic applicability, both real public controls passed again:
|
||||
timeout 60.443 s wall / 59.970344 s CPU / 3,078,295,552 B peak; default control
|
||||
63.574 s / 63.177884 s / 3,189,719,040 B. Analytical results, identities, coverage,
|
||||
BPE and exact CLI/MCP parity remain unchanged. JSON identifies the runtime and
|
||||
verifier source manifests for each cohort and keeps all earlier receipts.
|
||||
|
||||
Static `cl100k_base`/tiktoken 0.12.0 projections include the selected or complete
|
||||
name/description/inputSchema catalog, requests and structured Evidence or parsed
|
||||
text errors. Complete-tool-reply alternatives include MCP text/structured
|
||||
duplication. The selected two-tool catalog is 5,570 BPE; the complete projection
|
||||
is 195,522. Output schemas, host rendering/replay, notifications, model reasoning,
|
||||
final answers and billing are unmeasured. Repeated rounds, export, CLI parity,
|
||||
tokenization and exported-parent diagnostics are validation overhead outside the
|
||||
defined task tokens but inside resource receipts. Removing unsupported claims
|
||||
from the incorrect timeout baseline earns no efficiency credit.
|
||||
|
||||
## Verification and limitations
|
||||
|
||||
The initial production fix had 49 distinct passing cases across eight files. The initial
|
||||
pre-progress-cleanup seven-file selection passed 44/44. After progress cleanup,
|
||||
the same selection passed 43 and hit the existing 30-second test deadline in one
|
||||
native identity case; an unchanged two-file rerun passed both native cases and
|
||||
five public CLI cancellation cases. The original deadline was not increased.
|
||||
The runtime verifier collects interruption-bearing scopes; separate regressions
|
||||
cover native caller exclusion and malformed structured data. Source selection,
|
||||
malformed structures, actual worker resource constraints,
|
||||
retained large partial observations, cancellation/publication/cleanup, native
|
||||
identity and both public adapters remain covered.
|
||||
|
||||
The first review found that the real verifier previously accepted any non-JavaScript
|
||||
operation with artifact-byte authority and ignored phase-entry status. The
|
||||
scenario now supplies exact operation/status expectations independently of the
|
||||
production phase map. Six additional oracle cases use the actual retained
|
||||
Joplin snapshots and reject wrong metadata operations, entered or missing
|
||||
statuses, and absent or conflicting gaps. They passed, bringing the distinct
|
||||
coverage to 55 cases across nine files. The production implementation did not
|
||||
change during this review correction.
|
||||
|
||||
After the shared semantic-boundary correction from the second review, 78
|
||||
distinct cases passed across ten files: the nine-file selection passed 65/65,
|
||||
and the original root reconstruction file passed 13/13. This includes the
|
||||
alternate-builder owning test file's 23 cases. The new producer-boundary
|
||||
regression checks both construction paths, all five excluded metadata/native
|
||||
kinds, and selected/excluded JavaScript controls. Real Joplin controls exercise
|
||||
the public incremental workflow; the alternate full-builder path has filesystem
|
||||
boundary verification rather than a separately measured real-app workflow.
|
||||
|
||||
Recorded attempts also include the verifier's initial non-null-subject assumption
|
||||
and an invalid top-level semantic-module-path absence check. Both were corrected
|
||||
before their assertions were used as proof. Corrected cancellation reproduction
|
||||
shows the actual native AST scope and phantom module on the baseline. Final
|
||||
source and execution-driver versions, source pins, input digests, prior attempts
|
||||
and resource receipts are in the [compact JSON record](javascript-interruption-applicability-2026-10-15.json).
|
||||
|
||||
Before review, `npm run check && npm run docs:check` passed, including five consistency
|
||||
tests: 165.553 s wall / 150.247257 s CPU /
|
||||
4,232,491,008 B peak cgroup memory, clean owned exit and no OOM.
|
||||
The first full check stopped on a 172-line test callback exceeding the 150-line
|
||||
rule. A named assertion helper now shares scope lookup across all four public
|
||||
results; the strengthened six-case file passed again before the final gates.
|
||||
After the review correction, the full static/docs gate passed again, including
|
||||
the five consistency tests: 111.395 s wall / 110.979710 s CPU /
|
||||
4,347,125,760 B peak, with clean owned exit and no OOM.
|
||||
After centralizing semantic applicability, the final full static/docs gate also
|
||||
passed, including five consistency tests: 117.636 s wall / 117.194118 s CPU /
|
||||
4,263,153,664 B peak, clean owned exit and no OOM.
|
||||
|
||||
At the initial PR revision, 36 CI checks passed; macOS `hdiutil create` failed
|
||||
while creating its DMG fixture before REA verification, also failing the aggregate
|
||||
check. No Apple fixture/workflow code changed. That attempt provides no passing
|
||||
Apple runtime evidence.
|
||||
|
||||
Live Electron/application execution, real native-provider behavior, other-platform
|
||||
runtime coverage and hosted-agent costs are **NOT_ENOUGH_INFO**. The verification
|
||||
does not claim them.
|
||||
@@ -1,547 +0,0 @@
|
||||
{
|
||||
"base_revision": "e9a71efa31d6c3675b67938b8a79fa4ddf01604c",
|
||||
"scope": "Semantic per-value string-byte normalization; real static shipped-application control, no hosted-model performance claim",
|
||||
"runtime": {
|
||||
"platform": "Linux x64",
|
||||
"node": "24.18.0",
|
||||
"npm": "11.16.0",
|
||||
"tiktoken": "0.12.0"
|
||||
},
|
||||
"baseline_source_sha256": {
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "df3fc30b5ba91901a85fe56f200355930da32d054bb026a747e3414af233b6b5",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "c12b29f0faf4b6511777cba7ed8ac007c6d6170d657f01e43e194feacb3e0601",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0203d207e0d6bb8aaa17746090f008876a11653afd660fce3dc44f3fda646a6c",
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1"
|
||||
},
|
||||
"final_source_sha256": {
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1",
|
||||
"src/application/javascript/JavaScriptSemanticGraphDataProjection.ts": "844d4639401a9f050ce42c80192572a6d0d74fe4f81b37e93a2c20aaca9fb9a6",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.ts": "a3f802ca3446c2b5376cc58b19d818eff318e6775bd47752793c3f649994f8a2",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts": "2e78717d30e637b5fc5bab6d0eff063f7a62e0199d33697c1cdfaf8317baa698",
|
||||
"src/domain/javascript/javascriptSemanticDataEffectHelpers.ts": "8f9cf1a36f05b03dd816eaf9a6cdba0160d34ad7d17a961206e1bc32444d2ccc",
|
||||
"src/domain/javascript/javascriptSemanticDataEffects.ts": "e69408f2f5910a0107fd5d0cae0ff60ed706448857bc8e535c37cac1a0cd4d37",
|
||||
"src/domain/javascript/javascriptSemanticIr.ts": "68dad360d0a9e6bd72108b2717cae756b84ca1efb48455248ded2ff699d2c113",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "899eeb6ccdf666f504f8b722327599997c924c8e4fb13a1cbd13edaf08c96640",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0993a397f2a2a48c2b6c35494e940b3fce5c2c9032cfe33c7cf0401128c79dde",
|
||||
"src/domain/javascript/javascriptSemanticState.ts": "bfcface5dcda22594f47ed390efa15f9140fe41cb2d5995896e52dd0ee31b978",
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "a4ba51cc60fff38ef11fd5af35a2e1ad753cdb2dea9d44895f91d89320c5ddeb",
|
||||
"tests/acceptance/applications/javascriptEndpointPayload.test.ts": "b3cfcde1c5b5e0698f84afd51f4b53e42e56101267707c20c0d038320f5cfbd2",
|
||||
"tests/boundary/mcp/javascriptLiteralBudget.test.ts": "070106115b482269794799e448bd20b8e02df1f511f4ceb2b8fa75612c7f78e4",
|
||||
"tests/boundary/mcp/javascriptLiteralPayload.test.ts": "03618272c605f8877ed171ab39e037e4d80eac72b7478421640076f739adfb50"
|
||||
},
|
||||
"artifact": {
|
||||
"path": "/tmp/rea-codemode-experiment-20261015/artifacts/obsidian-1.14.4.asar",
|
||||
"sha256": "146ef8470d8cbb4a6db209bdc19bf2bad13350444186c0fd93c31087b142b92f"
|
||||
},
|
||||
"selected_source_paths": ["package.json", "main.js"],
|
||||
"where": {
|
||||
"path": "main.js",
|
||||
"kind": "javascript-module"
|
||||
},
|
||||
"identical_parent_evidence_id": "ev_73ef06e3b9b944f54c5257f7960279127d8518d2a73cd8618bd045dbe44e6b5a",
|
||||
"cli_parity": {
|
||||
"evidence_id": "ev_b3586dfdf7d4f01157f8f2978326aaa7103987110f2df4fa5bf3331ff2898749",
|
||||
"facts_sha256": "d3be5e91d2ec3fd9a95851cfbbdef9c168bb4c7153f78810b8b235e005401299",
|
||||
"exact_cli_mcp_view_parity": true
|
||||
},
|
||||
"unchanged_query_shapes": {
|
||||
"legacy": {
|
||||
"calls": 24,
|
||||
"structured_reply_bytes": 325201,
|
||||
"facts_sha256": "d3be5e91d2ec3fd9a95851cfbbdef9c168bb4c7153f78810b8b235e005401299",
|
||||
"matching_modules": 23,
|
||||
"coverage": {
|
||||
"status": "page",
|
||||
"examined": 55,
|
||||
"total": 55,
|
||||
"next_offset": null,
|
||||
"exhausted": true
|
||||
}
|
||||
},
|
||||
"references": {
|
||||
"calls": 1,
|
||||
"structured_reply_bytes": 22158,
|
||||
"facts_sha256": "d3be5e91d2ec3fd9a95851cfbbdef9c168bb4c7153f78810b8b235e005401299",
|
||||
"matching_modules": 23,
|
||||
"coverage": {
|
||||
"status": "page",
|
||||
"examined": 23,
|
||||
"total": 23,
|
||||
"next_offset": null,
|
||||
"exhausted": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"unchanged_token_costs": {
|
||||
"tokenizer": "cl100k_base",
|
||||
"tiktoken_version": "0.12.0",
|
||||
"costs": {
|
||||
"legacy": {
|
||||
"selected_catalog": 7977,
|
||||
"full_catalog": 195522,
|
||||
"common_request": 53,
|
||||
"common_summary": 2675,
|
||||
"requests": 2836,
|
||||
"structured_replies": 71761,
|
||||
"selected_catalog_task_total": 85302,
|
||||
"full_catalog_task_total": 272847
|
||||
},
|
||||
"references": {
|
||||
"selected_catalog": 7977,
|
||||
"full_catalog": 195522,
|
||||
"common_request": 53,
|
||||
"common_summary": 2675,
|
||||
"requests": 102,
|
||||
"structured_replies": 5741,
|
||||
"selected_catalog_task_total": 16548,
|
||||
"full_catalog_task_total": 204093
|
||||
}
|
||||
}
|
||||
},
|
||||
"cohorts": {
|
||||
"baseline": {
|
||||
"preparation_ms": 19089.119622,
|
||||
"query_samples": [
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 383.8260569999984
|
||||
},
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 15.778886999996757
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 13.15173700000014
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 240.44363500000327
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 346.04796499999793
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 13.727306999997381
|
||||
}
|
||||
],
|
||||
"resources": {
|
||||
"elapsed_seconds": 33.394,
|
||||
"cpu_seconds": 33.016802,
|
||||
"peak_cgroup_bytes": 1979863040,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"final": {
|
||||
"preparation_ms": 19061.292544,
|
||||
"query_samples": [
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 344.6316079999997
|
||||
},
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 14.438351000000694
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 11.38763100000142
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 298.41579600000114
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 211.45682099999976
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 10.275370999999723
|
||||
}
|
||||
],
|
||||
"resources": {
|
||||
"elapsed_seconds": 32.949,
|
||||
"cpu_seconds": 32.559187,
|
||||
"peak_cgroup_bytes": 1880096768,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"conditions": "First query is after shared artifact analysis; subsequent queries share one MCP session. Legacy item reads are serial; a concurrent legacy baseline is unmeasured. Filesystem/build warmness uncontrolled. Token costs count one post-change catalog, preparation request/summary and each request/structured reply once; client rendering, replay, reasoning, final answer and model latency are unmeasured. Preparation and parity/tokenization overhead are outside per-query elapsed times; external family-resource receipts include the complete verifier and children. Before/after used separate fresh MCP sessions. CPU/memory includes analysis, query arms, export, CLI parity and tokenization; cgroup memory includes file cache, not summed RSS. Counters are at payload exit while observer lives, not final scope counters. One before/after control establishes no speedup or equivalence bound. Catalog BPE projection excludes annotations/output schemas.",
|
||||
"resource_policy": {
|
||||
"memory_max_bytes": 8589934592,
|
||||
"early_stop_bytes": 6442450944,
|
||||
"cpu_quota_percent": 100,
|
||||
"swap": false
|
||||
},
|
||||
"observer_sources_sha256": {
|
||||
"resource-run.py": "7728862171415e7dee2c11af2ead2b9a54265fccaf82a7113956d36b29065e33",
|
||||
"resource_payload.py": "6f089e645459eba80c5d73e39c21606c78173a44daf49fabc3b88c4631ce51c6"
|
||||
},
|
||||
"regressions": {
|
||||
"original_main": "Quoted/template oversized literals failed through public CLI/MCP; addition/small controls passed. Corrected domain boundary reproduced 2 failures/16 passes.",
|
||||
"review_head": "8 failed/25 passed before fixes for projection tags, encountered-but-discarded limits and bare quoted/template defaults; includes exact null default control.",
|
||||
"interim_review_fix": "65/66 focused passed; old doubling-chain expectation omitted a genuine expression-depth limit now observed. Adjusted that assertion to preserve the byte-limit requirement while allowing other observed classes.",
|
||||
"final_focused": "66 passed across five files on the restored 38d263a runtime. Final corrected public selection passed 7/7 in two files: the six literal/default/member cases plus the augmented original large-endpoint acceptance. 67 distinct focused cases across invocations; not a single 67-case invocation.",
|
||||
"final_semantic_suite": "932 passed in 36 files on 38d263a. Final production src tree (including these domain tests) verified byte-identical to that revision; no repeated semantic run claimed.",
|
||||
"arithmetic": "Computed 174762*6+2=1048574 and 174763*6+2=1048580. Corrected the erroneous published 1048578 total.",
|
||||
"final_grouped_domain": "27 passed after grouping observations/defaults/allocation within function-size rules; no scenarios removed.",
|
||||
"endpoint_contract_correction": "Restored exact endpoint lookup identities rather than shrinking the existing large-endpoint fixture. Added the identical oversized string as an exported primitive in that acceptance workflow: literal normalization must report its bound while full endpoint lookup/feature trace/semantic trace/version comparison continue to work. Production src tree restored byte-identical to 38d263a; 932 semantic tests from that state remain applicable. Final corrected public tests/gates recorded after execution.",
|
||||
"final_corrected_gates": "Full static gate and docs gate (5 consistency tests) passed after endpoint identity restoration and strengthened unchanged-large-input acceptance. Production src remains byte-identical to 38d263a; final public 7/7 and fresh real control passed."
|
||||
},
|
||||
"prior_attempts": [
|
||||
{
|
||||
"stage": "Initial literal normalization, incomplete for member/default paths identified in review",
|
||||
"revision": "40b9d3c5b9cbeae7661d8e351e1b5ef6e5338931",
|
||||
"source_sha256": {
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "2debbb4f32d7d189819f2413f0f7d05b9bdcf497451a1c578475e3f2ec6c8554",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "899eeb6ccdf666f504f8b722327599997c924c8e4fb13a1cbd13edaf08c96640",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0203d207e0d6bb8aaa17746090f008876a11653afd660fce3dc44f3fda646a6c",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts": "747d893d6ddd91cf24d3b62b7eb50e0af9b1715ab355bbfc2e10ed0dc171ec17",
|
||||
"tests/boundary/mcp/javascriptLiteralBudget.test.ts": "46ceb5a169de3eec3a335b05ef4aa7b1b341a5ac06ad325bd191e862c5b6be70",
|
||||
"tests/boundary/mcp/javascriptLiteralPayload.test.ts": "03618272c605f8877ed171ab39e037e4d80eac72b7478421640076f739adfb50",
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1"
|
||||
},
|
||||
"real_control_cohort": {
|
||||
"preparation_ms": 18876.764036,
|
||||
"query_samples": [
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 346.7870870000006
|
||||
},
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 18.34765800000241
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 11.56626999999935
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 227.17703500000061
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 251.5148330000011
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 10.888227999999799
|
||||
}
|
||||
],
|
||||
"resources": {
|
||||
"elapsed_seconds": 31.347,
|
||||
"cpu_seconds": 31.05517,
|
||||
"peak_cgroup_bytes": 1589915648,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"validation": {
|
||||
"baseline_public": "Quoted and cooked-template cases retained 200000-unit normalized literals and failed; addition and small exact controls passed. Aggregate-capacity test passed.",
|
||||
"baseline_domain_corrected": "2 over-bound failures, 16 passed. Initial combined-run domain assertions had incorrectly required an empty optional resourceLimits array; corrected before using the domain reproduction as evidence.",
|
||||
"fixed_focused": "55 passed across five files.",
|
||||
"semantic_suite": "923 passed across 36 files.",
|
||||
"capacity_after_fixture_cleanup": "1 passed; all 16 bounded values, aggregate size >= original, typed identities and retained tracing preserved.",
|
||||
"interim_static_failure": "Typecheck rejected resume() on the new test SDK stderr Stream declaration. Switched to its declared data event, matching existing typed tests; analyzer source unchanged.",
|
||||
"public_boundary_after_stream_type_fix": "4 passed across actual CLI and stdio MCP; analyzer source unchanged."
|
||||
}
|
||||
},
|
||||
{
|
||||
"stage": "Projection/default correction; final review subsequently found unnormalized request endpoints",
|
||||
"revision": "38d263a369e7853ccfae1c8e0a3bd387f920c7cf",
|
||||
"source_sha256": {
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1",
|
||||
"src/application/javascript/JavaScriptSemanticGraphDataProjection.ts": "844d4639401a9f050ce42c80192572a6d0d74fe4f81b37e93a2c20aaca9fb9a6",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.ts": "a3f802ca3446c2b5376cc58b19d818eff318e6775bd47752793c3f649994f8a2",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts": "2e78717d30e637b5fc5bab6d0eff063f7a62e0199d33697c1cdfaf8317baa698",
|
||||
"src/domain/javascript/javascriptSemanticDataEffectHelpers.ts": "8f9cf1a36f05b03dd816eaf9a6cdba0160d34ad7d17a961206e1bc32444d2ccc",
|
||||
"src/domain/javascript/javascriptSemanticDataEffects.ts": "e69408f2f5910a0107fd5d0cae0ff60ed706448857bc8e535c37cac1a0cd4d37",
|
||||
"src/domain/javascript/javascriptSemanticIr.ts": "68dad360d0a9e6bd72108b2717cae756b84ca1efb48455248ded2ff699d2c113",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "899eeb6ccdf666f504f8b722327599997c924c8e4fb13a1cbd13edaf08c96640",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0993a397f2a2a48c2b6c35494e940b3fce5c2c9032cfe33c7cf0401128c79dde",
|
||||
"src/domain/javascript/javascriptSemanticState.ts": "bfcface5dcda22594f47ed390efa15f9140fe41cb2d5995896e52dd0ee31b978",
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "a4ba51cc60fff38ef11fd5af35a2e1ad753cdb2dea9d44895f91d89320c5ddeb",
|
||||
"tests/boundary/mcp/javascriptLiteralBudget.test.ts": "070106115b482269794799e448bd20b8e02df1f511f4ceb2b8fa75612c7f78e4",
|
||||
"tests/boundary/mcp/javascriptLiteralPayload.test.ts": "03618272c605f8877ed171ab39e037e4d80eac72b7478421640076f739adfb50"
|
||||
},
|
||||
"real_control_cohort": {
|
||||
"preparation_ms": 19599.643274,
|
||||
"query_samples": [
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 396.9265450000021
|
||||
},
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 15.658120000000054
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 12.24905100000251
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 237.03392900000108
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 357.78818299999693
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 14.37622100000226
|
||||
}
|
||||
],
|
||||
"resources": {
|
||||
"elapsed_seconds": 33.969,
|
||||
"cpu_seconds": 33.499223,
|
||||
"peak_cgroup_bytes": 1893015552,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"validation": {
|
||||
"original_main": "Quoted/template oversized literals failed through public CLI/MCP; addition/small controls passed. Corrected domain boundary reproduced 2 failures/16 passes.",
|
||||
"review_head": "8 failed/25 passed before fixes for projection tags, encountered-but-discarded limits and bare quoted/template defaults; includes exact null default control.",
|
||||
"interim_review_fix": "65/66 focused passed; old doubling-chain expectation omitted a genuine expression-depth limit now observed. Adjusted that assertion to preserve the byte-limit requirement while allowing other observed classes.",
|
||||
"final_focused": "66 passed in five files.",
|
||||
"final_semantic_suite": "932 passed in 36 files.",
|
||||
"arithmetic": "Computed 174762*6+2=1048574 and 174763*6+2=1048580. Corrected the erroneous published 1048578 total.",
|
||||
"final_grouped_domain": "27 passed after grouping observations/defaults/allocation within function-size rules; no scenarios removed.",
|
||||
"endpoint_review_baseline": "Production at 38d263a: 7 failed/14 passed across 13 new domain and 8 CLI/MCP cases before endpoint normalization. The later public linked-response case was not in this baseline run. Regression tests were uncommitted; final formatted test hashes are preserved, not claimed as the baseline test bytes.",
|
||||
"endpoint_selection_attempt": "First six-file selection exited before execution because a signed-zero test filename was mistyped; corrected the exact path. No test result claimed for that attempt."
|
||||
}
|
||||
},
|
||||
{
|
||||
"stage": "Rejected endpoint normalization: violated existing full-endpoint lookup/trace contract; reverted after CI acceptance failure",
|
||||
"revision": "580887209c4fceda432eac4083fac82a0dd78f15",
|
||||
"source_sha256": {
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1",
|
||||
"src/application/javascript/JavaScriptSemanticGraphDataProjection.ts": "a648f97e631985edcb5259ff4f1fdf0332dca18b8c10b57e050e36a785c1c524",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.requestBudget.test.ts": "8e84ffa70d834f5589d04118f0aaf33b0383b15ea97545ff69c66a74473aca73",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.ts": "a3f802ca3446c2b5376cc58b19d818eff318e6775bd47752793c3f649994f8a2",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts": "2e78717d30e637b5fc5bab6d0eff063f7a62e0199d33697c1cdfaf8317baa698",
|
||||
"src/domain/javascript/javascriptSemanticDataEffectHelpers.ts": "8f9cf1a36f05b03dd816eaf9a6cdba0160d34ad7d17a961206e1bc32444d2ccc",
|
||||
"src/domain/javascript/javascriptSemanticDataEffects.ts": "eed961e0b1d8a320e76bbba933408e950b4a4a446110401e8cf470f1e74d8315",
|
||||
"src/domain/javascript/javascriptSemanticIr.ts": "3b2ede73dbcfc74c4014e4d1affcbf00ecccc29a422ed495a7a3f2f517056c9b",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "899eeb6ccdf666f504f8b722327599997c924c8e4fb13a1cbd13edaf08c96640",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0993a397f2a2a48c2b6c35494e940b3fce5c2c9032cfe33c7cf0401128c79dde",
|
||||
"src/domain/javascript/javascriptSemanticState.ts": "bfcface5dcda22594f47ed390efa15f9140fe41cb2d5995896e52dd0ee31b978",
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "a4ba51cc60fff38ef11fd5af35a2e1ad753cdb2dea9d44895f91d89320c5ddeb",
|
||||
"tests/boundary/mcp/javascriptLiteralBudget.test.ts": "61319ea954de7f256841f43ca9355a1706ce8e93d30f2a8ba851d5e717bd19e7",
|
||||
"tests/boundary/mcp/javascriptLiteralPayload.test.ts": "03618272c605f8877ed171ab39e037e4d80eac72b7478421640076f739adfb50"
|
||||
},
|
||||
"real_control_cohort": {
|
||||
"preparation_ms": 19939.160272,
|
||||
"query_samples": [
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 348.3974309999976
|
||||
},
|
||||
{
|
||||
"round": 0,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 13.97052899999835
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 12.060379000002285
|
||||
},
|
||||
{
|
||||
"round": 1,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 212.01217800000086
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "legacy",
|
||||
"elapsed_ms": 223.73954800000138
|
||||
},
|
||||
{
|
||||
"round": 2,
|
||||
"mode": "references",
|
||||
"elapsed_ms": 10.450989999997546
|
||||
}
|
||||
],
|
||||
"resources": {
|
||||
"elapsed_seconds": 33.062,
|
||||
"cpu_seconds": 32.71624,
|
||||
"peak_cgroup_bytes": 1897406464,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"validation": {
|
||||
"original_main": "Quoted/template oversized literals failed through public CLI/MCP; addition/small controls passed. Corrected domain boundary reproduced 2 failures/16 passes.",
|
||||
"review_head": "8 failed/25 passed before fixes for projection tags, encountered-but-discarded limits and bare quoted/template defaults; includes exact null default control.",
|
||||
"interim_review_fix": "65/66 focused passed; old doubling-chain expectation omitted a genuine expression-depth limit now observed. Adjusted that assertion to preserve the byte-limit requirement while allowing other observed classes.",
|
||||
"final_focused": "81 passed in six files; the same CLI/MCP file then passed 9/9 after adding a linked-response case. That follow-up replaces its earlier 8-case coverage; 82 distinct cases across the final six-file selection, not one 82-case invocation.",
|
||||
"final_semantic_suite": "945 passed in 37 files, overlapping focused domain coverage.",
|
||||
"arithmetic": "Computed 174762*6+2=1048574 and 174763*6+2=1048580. Corrected the erroneous published 1048578 total.",
|
||||
"final_grouped_domain": "27 passed after grouping observations/defaults/allocation within function-size rules; no scenarios removed.",
|
||||
"endpoint_review_baseline": "Production at 38d263a: 7 failed/14 passed across 13 new domain and 8 CLI/MCP cases before endpoint normalization. The later public linked-response case was not in this baseline run. Regression tests were uncommitted; final formatted test hashes are preserved, not claimed as the baseline test bytes.",
|
||||
"endpoint_selection_attempt": "First six-file selection exited before execution because a signed-zero test filename was mistyped; corrected the exact path. No test result claimed for that attempt.",
|
||||
"endpoint_typecheck_attempt": "Full static gate found the inferred optional dataField in the public test computed key. Replaced the in-property check with an explicit bare === true discriminant; scenario inputs and runtime implementation unchanged. Corrected static/public checks recorded separately.",
|
||||
"final_gates": "Full static gate passed after the explicit test discriminant; final public file passed 9/9 again, then docs gate passed including 5 consistency tests. Runtime implementation unchanged after the 945-test semantic suite and real control."
|
||||
},
|
||||
"ci_failure": {
|
||||
"run_id": 38758262643,
|
||||
"job_id": 116503076738,
|
||||
"test": "tests/acceptance/applications/javascriptEndpointPayload.test.ts",
|
||||
"result": "1 failed/1573 passed/19 skipped; request endpoint no longer matched its complete source value. Other local tests and real Obsidian control passed but did not establish this compatibility contract.",
|
||||
"aggregate_result": "Merged source/built report: 1 failed/15625 passed/138 skipped. Portable tests and CI required failed as aggregates of the same endpoint assertion; no separate additional failed test."
|
||||
}
|
||||
}
|
||||
],
|
||||
"review_baseline_revision": "40b9d3c5b9cbeae7661d8e351e1b5ef6e5338931",
|
||||
"review_baseline_source_sha256": {
|
||||
"scripts/verify/javascript/module-references.mjs": "9d5f0b8b35ed2ebb4591f9dc3baea0fc116a0c3fd7d8e5ce30ec476c84671ed1",
|
||||
"src/application/javascript/JavaScriptSemanticGraphDataProjection.ts": "ee541e634264363822bf4ce05c42c72272029c7e8da72bbeed643ad1341d0756",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.ts": "a1cf791a61ee4742c351c006b69b64eba6bef3068f7a8450ed8f9366bfe4ff88",
|
||||
"src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts": "747d893d6ddd91cf24d3b62b7eb50e0af9b1715ab355bbfc2e10ed0dc171ec17",
|
||||
"src/domain/javascript/javascriptSemanticDataEffectHelpers.ts": "5ee7af18dd847726d8fe1828ea25f386ff9ef317d996a3f7969253bf73973cfa",
|
||||
"src/domain/javascript/javascriptSemanticDataEffects.ts": "4c62462016246bc7198294a74a60e87598fc009c53f1601abc2d4662d41b5bd1",
|
||||
"src/domain/javascript/javascriptSemanticIr.ts": "14955cb4b7912ed6a4f26f804a2480f841dcb6084dbddd15856375fa62cdcfa1",
|
||||
"src/domain/javascript/javascriptSemanticPrimitives.ts": "899eeb6ccdf666f504f8b722327599997c924c8e4fb13a1cbd13edaf08c96640",
|
||||
"src/domain/javascript/javascriptSemanticResourceLimits.ts": "0203d207e0d6bb8aaa17746090f008876a11653afd660fce3dc44f3fda646a6c",
|
||||
"src/domain/javascript/javascriptSemanticState.ts": "d94c5a88bb105284fab192406a8c88860d59f80c93394ed3ee7264969df254a6",
|
||||
"src/domain/javascript/javascriptSemanticValues.ts": "2debbb4f32d7d189819f2413f0f7d05b9bdcf497451a1c578475e3f2ec6c8554",
|
||||
"tests/boundary/mcp/javascriptLiteralBudget.test.ts": "46ceb5a169de3eec3a335b05ef4aa7b1b341a5ac06ad325bd191e862c5b6be70",
|
||||
"tests/boundary/mcp/javascriptLiteralPayload.test.ts": "03618272c605f8877ed171ab39e037e4d80eac72b7478421640076f739adfb50"
|
||||
},
|
||||
"implementation": "Per-analysis state records encountered resource classifications at expression/default normalization; final coverage consumes those facts. Slot projection preserves tagged unknown values. Removed retained-value recursive coverage scan and duplicate raw default reader. Defaults retain optional valueResourceLimit and graph value_resource_limit plus an anchored resource-limit unknown; known null/false/0/empty remain exact. Endpoint identities intentionally remain exact lookup values, outside the normalized primitive lattice; rejected endpoint normalization and its CI failure are preserved separately.",
|
||||
"restored_production_revision": "38d263a369e7853ccfae1c8e0a3bd387f920c7cf",
|
||||
"final_corrected_resource_receipts": {
|
||||
"public_7": {
|
||||
"elapsed_seconds": 43.621,
|
||||
"cpu_seconds": 43.097453,
|
||||
"peak_cgroup_bytes": 1520324608,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
},
|
||||
"static_and_docs": {
|
||||
"elapsed_seconds": 111.403,
|
||||
"cpu_seconds": 110.830839,
|
||||
"peak_cgroup_bytes": 4268244992,
|
||||
"payload_cleanup_verified": true,
|
||||
"events_at_payload_exit": {
|
||||
"memory.events": {
|
||||
"low": 0,
|
||||
"high": 0,
|
||||
"max": 0,
|
||||
"oom": 0,
|
||||
"oom_kill": 0,
|
||||
"oom_group_kill": 0
|
||||
},
|
||||
"pids.events": {
|
||||
"max": 0
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
# Semantic literal byte-budget verification
|
||||
|
||||
Tracks #3933 under #4027. All normalized semantic literals and configuration
|
||||
defaults use the primitive owner. Its singleton path validates strings/nonfinite
|
||||
numbers/negative zero without a Set, sorting or canonical-key serialization.
|
||||
Each source analysis owns a bounded set of encountered limit classifications;
|
||||
coverage consumes these observations after evaluation. This replaces a recursive
|
||||
scan that only saw retained binding/return values. No persistent cache is added.
|
||||
|
||||
## Correctness and coverage
|
||||
|
||||
Public CLI and actual stdio MCP cases cover quoted strings, cooked templates,
|
||||
equivalent concatenation, member receivers, a configuration-only expression
|
||||
statement and a small exact control. Direct/default oversized values become
|
||||
`resource-limit` unknowns with partial application coverage and
|
||||
`javascript_semantic_primitive_bytes = 1048576`. Defaults carry
|
||||
`value_resource_limit` inline and an unknown anchored to their config node.
|
||||
Known null/false/zero/empty defaults remain exact. Original source/digests and
|
||||
CLI/MCP identity parity are preserved.
|
||||
|
||||
Member and destructuring projections use the shared slot owner's tagged value.
|
||||
An encountered limit stays visible even when a subsequent projection selects a
|
||||
healthy sibling: the selected value remains exactly `7`, while file coverage is
|
||||
partial. This avoids inferring completeness from the final retained values alone.
|
||||
The duplicate raw default reader and superseded retained-value scan are removed.
|
||||
|
||||
Boundary controls admit 174,762 UTF-16 units (1,048,574 estimated JSON bytes)
|
||||
and reject 174,763 (1,048,580 bytes). Actual arithmetic corrected the earlier
|
||||
published 1,048,578 total; the unit-count boundary assertions were already correct.
|
||||
The estimate counts six bytes per unit plus two quotes. It does not establish
|
||||
actual ASCII JSON size above 1 MiB or an observed OOM.
|
||||
|
||||
The initial main baseline reproduced both public literal failures, with addition
|
||||
and small controls passing. A mistaken optional-limit-array control was corrected
|
||||
before the separate domain reproduction (2 failed/16 passed). Review head
|
||||
`40b9d3c5` then reproduced the additional projection/default gaps (8 failed,
|
||||
25 passed). The first review correction passed 65/66 focused tests; a doubling
|
||||
chain now truthfully retains an additional encountered expression-depth limit,
|
||||
so its byte-growth assertion was updated to allow other recorded limits.
|
||||
Prior validation on the restored runtime: **66 focused tests** in five files and **932 semantic tests**
|
||||
in 36 files, with overlapping domain coverage. The large-wire fixture retains
|
||||
16 individually admitted values and at least the former aggregate UTF-16 payload,
|
||||
plus complete CLI/MCP delivery, typed identities, empty strings and retained
|
||||
tracing. Inputs regenerate from the tests.
|
||||
|
||||
## Endpoint identity compatibility
|
||||
|
||||
An attempted endpoint normalization at `5808872` passed its new local cases and real Obsidian control, but failed the existing CI endpoint-payload acceptance workflow (1 failed/1,573 passed/19 skipped in that shard). It violated the established full endpoint lookup/trace contract. This extension was reverted; endpoint values are lookup identities, outside the normalized primitive lattice. The original large endpoint is preserved. Corrected public validation passed **7/7** across two files; this adds one acceptance workflow to the previous 66-case focused selection (**67 distinct cases**, not one 67-case invocation). Its acceptance workflow now also normalizes that identical string as an exported primitive, requiring the typed value bound while endpoint lookup, both trace workflows and version comparison remain usable. Prior measurements and failed attempts remain in the JSON record. Production source is restored byte-identical to `38d263a`; the 932-test semantic run belongs to that state. Final full static and documentation gates (five consistency tests) passed after the compatibility correction.
|
||||
|
||||
## Real application control and costs
|
||||
|
||||
Official Obsidian 1.14.4 ASAR, selected `package.json` and `main.js`. Follow the
|
||||
acquisition/digest and existing verifier command in
|
||||
[module-reference verification](javascript-module-references-2026-10-15.md).
|
||||
Use three alternating-order query pairs with CLI parity on each revision.
|
||||
Application code is not executed.
|
||||
|
||||
The final correction retains the exact baseline full parent/view Evidence IDs,
|
||||
23-row fact digest, source coverage and unknowns. Static `cl100k_base` task costs
|
||||
remain 16,548 with selected name/description/inputSchema contracts, or 204,093
|
||||
with the full catalog projection, for the reference workflow. Serial legacy
|
||||
reads also keep their original costs. The query projection improvement belongs
|
||||
to #4097; these are controls for semantic normalization and coverage.
|
||||
|
||||
| Complete real verifier | Before | Final correction |
|
||||
| ---------------------- | ------------: | ---------------: |
|
||||
| Elapsed seconds | 33.394 | 32.949 |
|
||||
| CPU seconds | 33.016802 | 32.559187 |
|
||||
| Peak cgroup bytes | 1,979,863,040 | 1,880,096,768 |
|
||||
|
||||
Includes initial analysis, both query arms, export, CLI parity and tokenizer.
|
||||
One CPU, 8 GiB hard cap, 6 GiB early stop, no swap; cleanup verified and no OOM.
|
||||
Memory includes charged file cache, not summed RSS. Counters are at payload exit
|
||||
while the observer remains alive. Fresh MCP sessions do not establish OS-cold
|
||||
cache conditions. Shared-host scheduling and filesystem/build warmness were
|
||||
uncontrolled. This one before/after control establishes neither a speedup nor
|
||||
an equivalence bound. Static BPE excludes annotations/output schemas, client
|
||||
rendering/replay, reasoning and final answers; no hosted agent was run. Linux
|
||||
static ASAR analysis was exercised, not live Electron or other platforms.
|
||||
|
||||
[Compact records, samples, source hashes and prior attempts](javascript-literal-byte-budget-2026-10-15.json)
|
||||
preserve the initial incomplete correction separately from the final measurements.
|
||||
No downloadable application or complete bundle is archived. Reproduce boundary
|
||||
outcomes through the listed public tests and reuse the existing real verifier
|
||||
and preserved 8 GiB observer linked above. Observer hashes and result-affecting
|
||||
touched source hashes are pinned in the records.
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,179 +0,0 @@
|
||||
# Native handoff byte-identity verification
|
||||
|
||||
Tracks #3926 under #4027. Baseline: `9f8659e0536e4e50a438f5b9d5661f3c9624f6ac`.
|
||||
Final integration base: `62bf09809ef7bb224028916424f8f07652a20f4f`.
|
||||
|
||||
The analyst already knows an ASAR-relative native path and supplies prior native
|
||||
Evidence. The question is which Evidence can be linked to that component's exact
|
||||
bytes. Discovery and native-provider execution are outside this task.
|
||||
|
||||
## Observed behavior and correction
|
||||
|
||||
The native-node producer distinguishes a content digest from a canonical path
|
||||
whose bytes are unavailable. Its unavailable observation legitimately cites the
|
||||
containing archive. The handoff consumer previously treated that supporting
|
||||
artifact digest as the native component's digest.
|
||||
|
||||
Public CLI/stdio MCP regression: the missing-companion case failed and the
|
||||
available-byte control passed. Real Joplin reproduced the same result: missing
|
||||
keytar bytes produced an `evidence-linked` handoff with the ASAR digest and the
|
||||
simulated container observation. CLI/MCP agreed on that incorrect answer.
|
||||
|
||||
The consumer now uses only the node owner's content-digest identity. The fallback
|
||||
observation scan is removed. Unavailable native nodes retain their canonical
|
||||
path, availability, container-backed provenance and partial coverage in the
|
||||
inline graph; they yield no false actionable handoff or native Evidence link.
|
||||
An empty handoff list describes eligibility, not absence of native components.
|
||||
The per-query node index is allocated only after an eligible target exists; no
|
||||
persistent cache, schema, tool or target authority is added.
|
||||
|
||||
Final real checks passed both cases with exact CLI/MCP trace parity. The available
|
||||
control preserved the complete parent/trace Evidence IDs, native facts, links,
|
||||
coverage and all token projections. The missing control preserved its parent,
|
||||
native node, source provenance and coverage, while removing the wrong handoff
|
||||
and container Evidence link.
|
||||
|
||||
## Real input and scope
|
||||
|
||||
[Official Joplin v3.7.21 Linux AppImage](https://github.com/laurent22/joplin/releases/download/v3.7.21/Joplin-3.7.21.AppImage),
|
||||
published 2026-09-25, 201,462,481 bytes, SHA-256
|
||||
`5d202dcaca31e14206826aa3f04125e7c218dbc3dc3d98479d811efbd6b856c1`.
|
||||
|
||||
Read-only 7z 26.02 inspection found 6,324 ASAR files, 46 unpacked entries and
|
||||
three `.node` components. Extract only the ASAR and those three binaries:
|
||||
|
||||
```sh
|
||||
input_root="$(mktemp -d -t rea-native-handoff-XXXXXX)"
|
||||
curl --fail --location --output "$input_root/Joplin-3.7.21.AppImage" \
|
||||
https://github.com/laurent22/joplin/releases/download/v3.7.21/Joplin-3.7.21.AppImage
|
||||
sha256sum "$input_root/Joplin-3.7.21.AppImage"
|
||||
7z x -mmt=1 "-o$input_root/extracted" "$input_root/Joplin-3.7.21.AppImage" \
|
||||
resources/app.asar \
|
||||
resources/app.asar.unpacked/node_modules/keytar/build/Release/keytar.node \
|
||||
resources/app.asar.unpacked/node_modules/sqlite3/lib/binding/napi-v6-linux-glibc-x64/node_sqlite3.node \
|
||||
resources/app.asar.unpacked/node_modules/onnxruntime-node/bin/napi-v6/linux/x64/onnxruntime_binding.node
|
||||
python3 - "$input_root" <<'PY'
|
||||
import os, sys
|
||||
from pathlib import Path
|
||||
root = Path(sys.argv[1])
|
||||
source = root / 'extracted/resources'
|
||||
for mode in ('available', 'missing'):
|
||||
case = root / 'cases' / mode
|
||||
case.mkdir(parents=True)
|
||||
os.link(source / 'app.asar', case / 'app.asar')
|
||||
if mode == 'available':
|
||||
for native in (source / 'app.asar.unpacked').rglob('*.node'):
|
||||
target = case / native.relative_to(source)
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
os.link(native, target)
|
||||
PY
|
||||
```
|
||||
|
||||
Verify the asset digest above before extraction. The ASAR is 233,575,014 bytes,
|
||||
SHA-256 `767df409b18effe60421fbefcca873de237c7e813eac744ecdeebbc5e825a33a`.
|
||||
Keytar is 76,960 bytes, SHA-256
|
||||
`0700016bcd761cbe02d275f2046c7cc42f39f730a50d66e3d3307aa9d413373a`.
|
||||
All extracted component hashes are in the JSON record. 7z reported one
|
||||
trailing-data warning for the AppImage's embedded SquashFS and exited 0.
|
||||
|
||||
Both cases select only `package.json` for static source analysis while retaining
|
||||
the inventory. The available case stages all three native companions; the other
|
||||
43 unpacked entries are not staged. The missing case stages none. Whole-application
|
||||
coverage is therefore partial in both cases, independently of the selected
|
||||
native component's known or unknown byte identity. Neither the application nor
|
||||
a native analysis provider is executed. Native Evidence is explicitly simulated
|
||||
to test exact subject linkage. Live Electron, real Ghidra/Hopper/IDA behavior and
|
||||
Windows/macOS verification are **NOT_ENOUGH_INFO**.
|
||||
|
||||
## Reproduce the public workflow
|
||||
|
||||
Use pinned Node 24.18.0/npm 11.16.0, `npm ci`, then `npm run build:cached`.
|
||||
The verifier returns compact records and deletes its private exported parent and
|
||||
CLI input after owned cleanup. No downloadable application or large Evidence is
|
||||
archived.
|
||||
|
||||
```sh
|
||||
for mode in available missing; do
|
||||
node scripts/verify/javascript/native-handoffs.mjs \
|
||||
--artifact "$input_root/cases/$mode/app.asar" \
|
||||
--addon-path node_modules/keytar/build/Release/keytar.node \
|
||||
--native-sha256 0700016bcd761cbe02d275f2046c7cc42f39f730a50d66e3d3307aa9d413373a \
|
||||
--source-path package.json --rounds 3 --cli-parity --require-safe
|
||||
done
|
||||
```
|
||||
|
||||
Add `--tokenizer-python /absolute/path/to/python-with-tiktoken-0.12.0` for the
|
||||
reported BPE projections. The npm alias `verify:javascript:native-handoffs`
|
||||
builds first; recorded costs use the direct Node invocation above after building.
|
||||
For a pre-fix observation, run the saved verifier on the baseline build without
|
||||
`--require-safe`; `safe_identity: false` is an incorrect answer, not a passing
|
||||
analyst task. Paths affect serialized requests and some Evidence identities.
|
||||
|
||||
The exact resource runs additionally used the preserved
|
||||
[8 GiB observer](https://github.com/morluto/rea/blob/b3bdabab694af1f9801eff7caf75001b92314a58/experiments/analysis-efficiency/resource-run.py)
|
||||
and adjacent `resource_payload.py`; both hashes are pinned in the JSON.
|
||||
|
||||
## Completed workflow costs and limits
|
||||
|
||||
| Case | Revision | Wall s | CPU s | Peak cgroup bytes | Identity oracle |
|
||||
| ---------------------- | -------- | ------: | ---------: | ----------------: | -------------------------- |
|
||||
| Native bytes available | Before | 60.369 | 59.806670 | 2,662,629,376 | pass |
|
||||
| Native bytes available | After | 258.885 | 106.221003 | 2,678,456,320 | pass, exact baseline facts |
|
||||
| Native bytes missing | Before | 57.930 | 57.479109 | 2,719,457,280 | wrong identity/linkage |
|
||||
| Native bytes missing | After | 59.738 | 59.254776 | 2,571,235,328 | pass, unknown retained |
|
||||
|
||||
Whole-verifier resources include input hashing, analysis, three retained trace
|
||||
queries, export, CLI parity and tokenization. One CPU, 8 GiB hard cap, 6 GiB early
|
||||
stop, no swap; cleanup verified and no OOM. Memory includes charged file cache,
|
||||
not summed RSS. Counters are at payload exit while the observer remains alive.
|
||||
The available control's final wall and CPU times are substantially higher than
|
||||
baseline. Earlier post-fix controls on the original base took 61.657/74.956 s wall
|
||||
and 61.135962/60.352428 s CPU for available/missing cases; their complete receipts
|
||||
remain separately recorded. The final missing case took 59.738 s wall. This
|
||||
variability is unresolved and cannot be attributed to the native consumer change.
|
||||
These runs establish neither speedup nor performance equivalence. Input hashing warms the ASAR
|
||||
cache, build/OS caches and shared-host scheduling are uncontrolled. Fresh MCP
|
||||
sessions do not establish OS-cold conditions. First post-analysis and repeated
|
||||
warm-query samples are preserved separately; query CPU/memory are unmeasured.
|
||||
|
||||
One defined task is one analysis summary plus one retained trace, with the path
|
||||
and prior Evidence already supplied. Static `cl100k_base`/tiktoken 0.12.0 counts
|
||||
include both requests, replies and name/description/inputSchema contracts:
|
||||
|
||||
| Available-byte task, unchanged before/after | BPE tokens |
|
||||
| ----------------------------------------------- | ---------: |
|
||||
| Selected catalog + structured replies | 12,340 |
|
||||
| Selected catalog + complete tool replies | 18,906 |
|
||||
| Full catalog projection + structured replies | 202,292 |
|
||||
| Full catalog projection + complete tool replies | 208,858 |
|
||||
|
||||
These are alternative reply/catalog projections. The selected catalog alone is
|
||||
5,570 BPE; the full projection is 195,522. Output schemas, annotations, host
|
||||
rendering/replay, reasoning, final answers and model billing are unmeasured.
|
||||
Repeated queries/export/CLI/tokenization are validation overhead outside this
|
||||
one-task token count, but inside resource receipts. Missing-case structured-task
|
||||
counts change 11,372 → 11,103 by removing unsupported claims; the incorrect
|
||||
baseline earns no efficiency credit.
|
||||
|
||||
## Regression and verification record
|
||||
|
||||
The initial four-file focused selection passed 24 tests. The two public cases
|
||||
were rerun after adding named summary-result parsing and correcting an optional
|
||||
architecture factory input. Omitting that field instead of passing null produced
|
||||
byte-identical normalized simulated Evidence in all four real-case inputs.
|
||||
The initial CLI-selector harness error and first typecheck failure are retained
|
||||
as harness/validation attempts, not product reproductions.
|
||||
|
||||
After syncing the reviewed upstream changes, the updated application workflow
|
||||
CLI acceptance file passed 34 tests, bringing the focused selection to 58 distinct
|
||||
cases across five files. Both Joplin controls were then repeated on the final
|
||||
integration base. Canonical byte identity is also used by the related version
|
||||
matching/content comparison consumers; no equivalent observation-digest fallback
|
||||
was found there.
|
||||
|
||||
Final `npm run check && npm run docs:check` passed on the integration base,
|
||||
including five documentation consistency tests: 128.732 s wall, 115.518920 s CPU,
|
||||
4,301,684,736 B peak cgroup memory, clean owned exit and no OOM.
|
||||
|
||||
Final public and static/docs outcomes are recorded in the
|
||||
[compact measurements and source pins](javascript-native-handoff-identity-2026-10-15.json).
|
||||
@@ -10,6 +10,7 @@
|
||||
"scripts/verify/fridaBindingsCompatibility.ts",
|
||||
"scripts/verify/termux/browser.mjs",
|
||||
"scripts/verify-real-ghidra-noreturn.mjs",
|
||||
"scripts/run-exact-tests.mjs",
|
||||
"tests/processOwnershipRunner.ts"
|
||||
],
|
||||
"project": ["src/**/*.ts", "tests/**/*.ts", "scripts/**/*.mjs"],
|
||||
|
||||
@@ -111,14 +111,9 @@ automatically. Alternatively, build it using the Linux/MinGW lane above.
|
||||
- Cleanup walks locked directory objects, removes files by handle, and unlinks
|
||||
reparse entries without traversing their targets. Failed removal retains the
|
||||
root and ancestor leases for retry; a partially removed runtime accepts only
|
||||
cleanup, and its registry entry remains until removal succeeds. The runtime
|
||||
owner retries only native close failures with Win32 sharing/lock codes 32/33,
|
||||
for at most ten attempts with a 100 ms delay between attempts. Other native
|
||||
errors are returned immediately; exhausting the retry budget preserves the
|
||||
runtime owner for a later explicit close. These cleanup retries do not use an
|
||||
analysis cancellation signal and schedule up to 900 ms of backoff, in
|
||||
addition to native cleanup time. The owned root handle includes attribute-write access so cleanup can clear a
|
||||
read-only marker, matching the child cleanup handles. Normal close, cancellation,
|
||||
cleanup, and its registry entry remains until removal succeeds. The owned root
|
||||
handle includes attribute-write access so cleanup can clear a read-only marker,
|
||||
matching the child cleanup handles. Normal close, cancellation,
|
||||
startup failure, and timeout release provider resources. Abrupt owner death
|
||||
kills the owned job. The Android provider additionally uses a detached helper
|
||||
that owns its private runtime directory and cleans it when the owner pipe
|
||||
@@ -138,9 +133,7 @@ text do not establish a safe retry. Analysis errors propagate the producer's
|
||||
retry disposition through JavaScript, source-map and WABT workflows; transient
|
||||
failures report `category: unavailable` and retain the original reason.
|
||||
Incomplete cleanup blocks an operation retry until its owned resources settle.
|
||||
The close-stage retry is separate from allocation and analysis retries: it
|
||||
repeats only the existing owned cleanup operation, and does not retry provider
|
||||
work or create another runtime.
|
||||
REA adds no automatic retry loop or new analysis cache for this behavior.
|
||||
|
||||
Ordinary drive-absolute paths accept backslashes, forward slashes, or mixed
|
||||
separators. File identity retains the original requested spelling. Separator
|
||||
|
||||
@@ -214,7 +214,6 @@
|
||||
"verify:javascript:digests": "npm run build:cached && node scripts/verify/javascript/digests.mjs",
|
||||
"verify:javascript:output": "npm run build:cached && node scripts/verify/javascript/output.mjs",
|
||||
"verify:javascript:module-references": "npm run build:cached && node scripts/verify/javascript/module-references.mjs",
|
||||
"verify:javascript:native-handoffs": "npm run build:cached && node scripts/verify/javascript/native-handoffs.mjs",
|
||||
"verify:application-workflows": "npm run build:cached && node scripts/verify/javascript/application-workflows.mjs",
|
||||
"verify:managed": "npm run build:cached && node scripts/verify/managed/conformance.mjs",
|
||||
"verify:firmware": "npm run build:cached && node scripts/verify/firmware/analysis.mjs",
|
||||
@@ -273,7 +272,6 @@
|
||||
"verify:windows-native": "node scripts/verify-windows-native.mjs",
|
||||
"verify:ghidra:windows:package": "node scripts/verify-packaged-ghidra-windows.mjs",
|
||||
"build:ghidra:nativeaot": "node scripts/build-ghidra-nativeaot.mjs",
|
||||
"verify:ghidra:bridge-sources": "node scripts/verify-ghidra-bridge-sources.mjs",
|
||||
"build:fixtures:nativeaot": "node scripts/generate-nativeaot-fixtures.mjs",
|
||||
"verify:ghidra:nativeaot": "npm run build:cached && node scripts/verify-real-ghidra-nativeaot.mjs",
|
||||
"verify:browser:scripts": "npm run build:cached && node scripts/verify-browser-scripts.mjs",
|
||||
|
||||
@@ -157,7 +157,7 @@ function propertyValue(content, name) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Release line supported by the separately pinned NativeAOT integration. */
|
||||
/** Same 12.1 line as GhidraInstallationPolicy, including a distro suffix. */
|
||||
function ghidraReleaseLineAccepted(raw) {
|
||||
const match = /^(\d+)\.(\d+)(?:\.(\d+))?([-+].*)?$/u.exec(raw ?? "");
|
||||
return match !== null && Number(match[1]) === 12 && Number(match[2]) === 1;
|
||||
|
||||
@@ -104,7 +104,6 @@ export const SCOPES = {
|
||||
"tests/boundary/filesystem/npmRelease.test.ts",
|
||||
"tests/boundary/process/releaseArtifactCanary.test.ts",
|
||||
"src/windows/**",
|
||||
"src/ghidra/GhidraBridgeSources.ts",
|
||||
"native/windows/**",
|
||||
"src/process/capture/FilesystemSnapshot.ts",
|
||||
"src/process/capture/FilesystemSnapshot.test.ts",
|
||||
@@ -139,7 +138,6 @@ export const SCOPES = {
|
||||
"src/domain/javascript/javascriptRuntimeStaticCandidates.ts",
|
||||
"tests/boundary/filesystem/webScriptManifestPaths.test.ts",
|
||||
"tests/boundary/process/ProcessEvidence.host.test.ts",
|
||||
"tests/boundary/process/packageNpmInvocation.test.ts",
|
||||
"tests/boundary/process/windowsOutputCapture.test.ts",
|
||||
"tests/acceptance/webModuleCli.test.ts",
|
||||
"tests/acceptance/webSourceLocationCli.test.ts",
|
||||
@@ -437,14 +435,6 @@ export const SCOPES = {
|
||||
"tests/fixtures/nativeaot/**",
|
||||
".github/workflows/nativeaot-fixtures.yml",
|
||||
],
|
||||
ghidra_bridge: [
|
||||
"bridge/ghidra/**",
|
||||
"src/ghidra/GhidraBridgeSources.ts",
|
||||
"src/ghidra/GhidraJavaProperties.ts",
|
||||
"src/ghidra/GhidraReleasePolicy.ts",
|
||||
"scripts/verify-ghidra-bridge-sources.mjs",
|
||||
".github/workflows/ghidra-bridge-sources.yml",
|
||||
],
|
||||
website: [
|
||||
"website/**",
|
||||
"scripts/*website*.py",
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
import type { z } from "zod";
|
||||
|
||||
export interface StructuredScopeExpectation {
|
||||
readonly operation:
|
||||
| "parse-package-json"
|
||||
| "parse-json-module"
|
||||
| "parse-html-script-references"
|
||||
| "parse-local-source-map";
|
||||
readonly analysis_status: "interrupted" | "not-started";
|
||||
}
|
||||
|
||||
export interface StructuredProcessingScope {
|
||||
readonly properties: Readonly<Record<string, unknown>>;
|
||||
readonly evidence: {
|
||||
readonly authority: string;
|
||||
readonly state: string;
|
||||
readonly confidence: string;
|
||||
};
|
||||
}
|
||||
|
||||
export const structuredScopeExpectationsSchema: z.ZodType<
|
||||
Record<string, StructuredScopeExpectation>
|
||||
>;
|
||||
|
||||
export function matchesStructuredScopeExpectation(
|
||||
scopes: readonly StructuredProcessingScope[],
|
||||
expected: StructuredScopeExpectation | undefined,
|
||||
): boolean;
|
||||
@@ -1,28 +0,0 @@
|
||||
import { z } from "zod";
|
||||
|
||||
/** Independent expected outcomes supplied by the verification scenario. */
|
||||
export const structuredScopeExpectationsSchema = z.record(
|
||||
z.string().min(1),
|
||||
z.strictObject({
|
||||
operation: z.enum([
|
||||
"parse-package-json",
|
||||
"parse-json-module",
|
||||
"parse-html-script-references",
|
||||
"parse-local-source-map",
|
||||
]),
|
||||
analysis_status: z.enum(["interrupted", "not-started"]),
|
||||
}),
|
||||
);
|
||||
|
||||
/** Every retained gap must match the named phase and its unavailable status. */
|
||||
export const matchesStructuredScopeExpectation = (scopes, expected) =>
|
||||
expected !== undefined &&
|
||||
scopes.length > 0 &&
|
||||
scopes.every(
|
||||
({ evidence, properties }) =>
|
||||
evidence.authority === "artifact-bytes" &&
|
||||
evidence.state === "unavailable" &&
|
||||
evidence.confidence === "unknown" &&
|
||||
properties.operation === expected.operation &&
|
||||
properties.analysis_status === expected.analysis_status,
|
||||
);
|
||||
@@ -17,7 +17,7 @@ export const SOURCE_TEST_PROJECTS = [
|
||||
group: "source",
|
||||
include: [
|
||||
"src/*.test.ts",
|
||||
"src/{apktool,jeb,adb,artifacts,browser,dotnet,electron,evm,firmware,flutter,pcap,ghidra,go,hopper,ida,inspector,javascript,native,process,reference,rust,server,sqlite,wasm,windows}/**/*.test.ts",
|
||||
"src/{apktool,jeb,adb,artifacts,browser,dotnet,electron,evm,firmware,flutter,pcap,ghidra,go,hopper,ida,inspector,javascript,native,process,reference,rust,server,wasm,windows}/**/*.test.ts",
|
||||
],
|
||||
},
|
||||
{
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import { execFile } from "node:child_process";
|
||||
import { lstat } from "node:fs/promises";
|
||||
import { dirname, join } from "node:path";
|
||||
import { promisify } from "node:util";
|
||||
import { Ajv2020 } from "ajv/dist/2020.js";
|
||||
|
||||
@@ -18,25 +17,6 @@ const loadMcpVerifierResults = () => import("./mcp-verifier-results.mjs");
|
||||
/** Promisified child_process execution helper. */
|
||||
export const exec = promisify(execFile);
|
||||
|
||||
/** Run npm through its JavaScript entry point so Windows command scripts are not required. */
|
||||
export const execNpm = (arguments_, options = {}) => {
|
||||
const environment = options.env ?? process.env;
|
||||
const selectedEntry = environment.npm_execpath;
|
||||
if (
|
||||
selectedEntry !== undefined &&
|
||||
(typeof selectedEntry !== "string" || selectedEntry.length === 0)
|
||||
)
|
||||
throw new Error("npm_execpath must name the selected npm CLI entry point");
|
||||
const entry =
|
||||
selectedEntry ??
|
||||
(process.platform === "win32"
|
||||
? join(dirname(process.execPath), "node_modules/npm/bin/npm-cli.js")
|
||||
: undefined);
|
||||
return entry === undefined
|
||||
? exec("npm", arguments_, options)
|
||||
: exec(process.execPath, [entry, ...arguments_], options);
|
||||
};
|
||||
|
||||
/** Run a command and return its stdout. */
|
||||
export const run = async (command, args, env) =>
|
||||
(await exec(command, args, { env })).stdout;
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
// A single inspection can include native admission plus several WABT commands.
|
||||
// The aggregate verifier covers seven complete fixtures and their failure paths.
|
||||
export const WABT_OPERATION_TIMEOUT_MS = 4 * 60_000;
|
||||
export const WABT_WORKFLOW_TIMEOUT_MS = 15 * 60_000;
|
||||
@@ -76,30 +76,13 @@ function runCommand() {
|
||||
env: process.env,
|
||||
stdio: "inherit",
|
||||
});
|
||||
let spawned = false;
|
||||
let childError;
|
||||
let hasChildError = false;
|
||||
child.once("spawn", () => {
|
||||
spawned = true;
|
||||
});
|
||||
const rememberChildError = (cause) => {
|
||||
if (!hasChildError) {
|
||||
hasChildError = true;
|
||||
childError = cause;
|
||||
}
|
||||
if (!spawned) {
|
||||
reject(childError);
|
||||
}
|
||||
};
|
||||
child.on("error", rememberChildError);
|
||||
child.once("error", reject);
|
||||
child.once("close", (code) => {
|
||||
child.off("error", rememberChildError);
|
||||
// During POSIX cancellation the group leader must stay alive, retaining
|
||||
// both its group identity and SQLite ownership until the entire group is
|
||||
// killed. A completed command can still have uncooperative descendants.
|
||||
if (shutdownSignal !== undefined && process.platform !== "win32") return;
|
||||
if (hasChildError) reject(childError);
|
||||
else resolveResult({ code });
|
||||
if (shutdownSignal === undefined || process.platform === "win32")
|
||||
resolveResult({ code });
|
||||
});
|
||||
});
|
||||
}
|
||||
@@ -116,13 +99,7 @@ function handleDisconnect() {
|
||||
function handleSignal(signal) {
|
||||
if (shutdownSignal !== undefined) return;
|
||||
shutdownSignal = signal;
|
||||
if (child === undefined) return;
|
||||
if (process.platform === "win32") {
|
||||
// Windows has no POSIX process groups. Stop only the command owned by this
|
||||
// supervisor, and keep the SQLite transaction until its close event.
|
||||
child.kill(signal);
|
||||
return;
|
||||
}
|
||||
if (child === undefined || process.platform === "win32") return;
|
||||
// Establish cancellation before signalling the group. This supervisor is
|
||||
// its live leader, so the group identifier cannot be reused during cleanup.
|
||||
process.kill(-process.pid, signal);
|
||||
|
||||
@@ -322,47 +322,6 @@ class WebsiteMaintenanceChecks(unittest.TestCase):
|
||||
self.assertTrue(any("missing Markdown fragment" in error for error in errors))
|
||||
self.assertTrue(any("missing repository target" in error for error in errors))
|
||||
|
||||
def test_repository_links_accept_aliased_roots_and_reject_escaping_links(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = (Path(directory) / "repository").resolve()
|
||||
(root / "website/public").mkdir(parents=True)
|
||||
(root / "docs").mkdir()
|
||||
(root / "docs/guide.md").write_text("# Guide\n")
|
||||
page = root / "website/README.md"
|
||||
page.write_text("[Guide](../docs/guide.md#guide)\n")
|
||||
alias = Path(directory) / "repository-alias"
|
||||
alias.symlink_to(root, target_is_directory=True)
|
||||
self.assertEqual(VERIFY.check_repository_links(root), [])
|
||||
self.assertEqual(VERIFY.check_repository_links(alias), [])
|
||||
(root.parent / "outside.md").write_text("# Outside\n")
|
||||
page.write_text("[Outside](../../outside.md)\n")
|
||||
for boundary in (root, alias):
|
||||
with self.subTest(boundary=boundary):
|
||||
self.assertEqual(VERIFY.check_repository_links(boundary), [
|
||||
"website/README.md: missing repository target: ../../outside.md"
|
||||
])
|
||||
|
||||
def test_site_links_preserve_containment_through_aliased_roots(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
site = (Path(directory) / "site").resolve()
|
||||
site.mkdir()
|
||||
page = site / "index.html"
|
||||
page.write_text('<html lang="en"><head><title>Fixture</title><meta name="robots" content="noindex"></head><body><h1>Fixture</h1><a href="guide.html#answer">Guide</a></body></html>')
|
||||
(site / "guide.html").write_text('<html lang="en"><head><title>Guide</title><meta name="robots" content="noindex"></head><body><h1 id="answer">Answer</h1></body></html>')
|
||||
(site / "sitemap.xml").write_text('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"/>')
|
||||
(site / "robots.txt").write_text("User-agent: *\nAllow: /\nSitemap: https://rea.tools/sitemap.xml\n")
|
||||
alias = Path(directory) / "site-alias"
|
||||
alias.symlink_to(site, target_is_directory=True)
|
||||
# The tiny link fixture intentionally omits the social preview.
|
||||
expected = ["Social preview PNG is missing; run scripts/prepare-website.py"]
|
||||
self.assertEqual(VERIFY.check_site(site)[3], expected)
|
||||
self.assertEqual(VERIFY.check_site(alias)[3], expected)
|
||||
(site.parent / "outside.html").write_text("<p>Outside</p>")
|
||||
page.write_text(page.read_text().replace("guide.html#answer", "../outside.html"))
|
||||
for boundary in (site, alias):
|
||||
with self.subTest(boundary=boundary):
|
||||
self.assertIn("index.html: reference leaves the website: ../outside.html", VERIFY.check_site(boundary)[3])
|
||||
|
||||
def test_preview_preserves_pages_prefix_for_assets_and_directory_redirects(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
site = Path(directory)
|
||||
|
||||
+305
-328
@@ -5,7 +5,6 @@ import { join } from "node:path";
|
||||
|
||||
import { AdbDeviceAnalysisService } from "../dist/application/adb/AdbDeviceAnalysisService.js";
|
||||
import { createAdbDeviceAnalysisProvider } from "../dist/composition/adb.js";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
|
||||
const options = parseArguments(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
@@ -40,365 +39,343 @@ const run = async (operation, input) => {
|
||||
return result.value.normalized_result;
|
||||
};
|
||||
|
||||
let primaryFailure;
|
||||
try {
|
||||
const client = await run("inspect_adb_client", {});
|
||||
if (client !== null) {
|
||||
const client = await run("inspect_adb_client", {});
|
||||
if (client !== null) {
|
||||
check(
|
||||
"adb client reports a version",
|
||||
typeof client.client.version === "string" && client.client.version !== "",
|
||||
`binary=${client.client.binary_path} version=${client.client.version}`,
|
||||
);
|
||||
}
|
||||
|
||||
const listing = await run("list_adb_devices", {});
|
||||
let serial = options.serial ?? null;
|
||||
if (listing !== null) {
|
||||
check(
|
||||
"device listing parsed",
|
||||
Array.isArray(listing.devices),
|
||||
`${listing.devices.length} device(s)`,
|
||||
);
|
||||
const usable = listing.devices.filter((device) => device.state === "device");
|
||||
if (serial === null && usable.length > 0) serial = usable[0].serial;
|
||||
if (serial === null) {
|
||||
process.stdout.write(
|
||||
"[FAIL] no usable device is attached; start an emulator or connect a phone\n",
|
||||
);
|
||||
failures += 1;
|
||||
} else {
|
||||
const selected = listing.devices.find((device) => device.serial === serial);
|
||||
check(
|
||||
"adb client reports a version",
|
||||
typeof client.client.version === "string" && client.client.version !== "",
|
||||
`binary=${client.client.binary_path} version=${client.client.version}`,
|
||||
"selected device present with a kind inference",
|
||||
selected !== undefined &&
|
||||
["emulator", "physical", "unknown"].includes(selected.kind),
|
||||
`serial=${serial} kind=${selected?.kind} basis=${selected?.kind_basis}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (serial !== null) {
|
||||
const device = await run("inspect_adb_device", { serial });
|
||||
if (device !== null) {
|
||||
check(
|
||||
"device build identity projected",
|
||||
device.properties.some(
|
||||
(property) => property.name === "ro.build.version.sdk",
|
||||
),
|
||||
`sdk=${
|
||||
device.properties.find((p) => p.name === "ro.build.version.sdk")?.value
|
||||
} emulator_observed=${String(device.emulator_observed)}`,
|
||||
);
|
||||
}
|
||||
|
||||
const listing = await run("list_adb_devices", {});
|
||||
let serial = options.serial ?? null;
|
||||
if (listing !== null) {
|
||||
// Observation tools: processes, window, display, settings, logcat.
|
||||
const processes = await run("list_adb_processes", { serial });
|
||||
if (processes !== null) {
|
||||
check(
|
||||
"device listing parsed",
|
||||
Array.isArray(listing.devices),
|
||||
`${listing.devices.length} device(s)`,
|
||||
"process listing is non-empty with a header",
|
||||
processes.processes.length > 0 && typeof processes.columns === "string",
|
||||
`${processes.processes.length} process(es)`,
|
||||
);
|
||||
const usable = listing.devices.filter(
|
||||
(device) => device.state === "device",
|
||||
}
|
||||
const window = await run("inspect_adb_window", { serial });
|
||||
if (window !== null)
|
||||
check(
|
||||
"window focus observation completed",
|
||||
typeof window.focused_window === "string" ||
|
||||
window.focused_window === null,
|
||||
`focused_window=${String(window.focused_window).slice(0, 60)} (null is legitimate on headless devices)`,
|
||||
);
|
||||
if (serial === null && usable.length > 0) serial = usable[0].serial;
|
||||
if (serial === null) {
|
||||
process.stdout.write(
|
||||
"[FAIL] no usable device is attached; start an emulator or connect a phone\n",
|
||||
);
|
||||
failures += 1;
|
||||
} else {
|
||||
const selected = listing.devices.find(
|
||||
(device) => device.serial === serial,
|
||||
);
|
||||
const display = await run("inspect_adb_display", { serial });
|
||||
if (display !== null)
|
||||
check(
|
||||
"display reports a physical size",
|
||||
display.physical_size !== null &&
|
||||
display.physical_size.width > 0 &&
|
||||
display.physical_size.height > 0,
|
||||
`${display.physical_size?.width}x${display.physical_size?.height} @${String(display.physical_density)}`,
|
||||
);
|
||||
const setting = await run("read_adb_setting", {
|
||||
serial,
|
||||
namespace: "global",
|
||||
key: "adb_enabled",
|
||||
});
|
||||
if (setting !== null)
|
||||
check(
|
||||
"settings read returns the device's own value",
|
||||
setting.value === "1",
|
||||
`adb_enabled=${String(setting.value)}`,
|
||||
);
|
||||
const logcat = await run("read_adb_logcat", {
|
||||
serial,
|
||||
count: 20,
|
||||
buffer: "main",
|
||||
});
|
||||
if (logcat !== null)
|
||||
check(
|
||||
"logcat dump returns bounded lines",
|
||||
logcat.lines.length <= 20,
|
||||
`${logcat.lines.length} line(s), coverage=${logcat.coverage}`,
|
||||
);
|
||||
const features = await run("list_adb_features", { serial });
|
||||
if (features !== null)
|
||||
check(
|
||||
"feature inventory is non-empty",
|
||||
features.coverage === "complete" && features.features.length > 0,
|
||||
`${features.features.length} feature(s)`,
|
||||
);
|
||||
const services = await run("list_adb_services", { serial });
|
||||
if (services !== null)
|
||||
check(
|
||||
"service inventory is non-empty",
|
||||
services.coverage === "complete" && services.services.length > 0,
|
||||
`${services.services.length} service(s)`,
|
||||
);
|
||||
const directory = await run("list_adb_directory", {
|
||||
serial,
|
||||
device_path: "/data/local/tmp",
|
||||
});
|
||||
if (directory !== null)
|
||||
check(
|
||||
"directory listing completed",
|
||||
directory.coverage === "complete",
|
||||
`${directory.entries.length} entr(ies)`,
|
||||
);
|
||||
|
||||
const packages = await run("list_adb_packages", {
|
||||
serial,
|
||||
scope: "third_party",
|
||||
});
|
||||
let pullCandidate = options.pull ?? null;
|
||||
if (packages !== null) {
|
||||
// A third-party scope may legitimately be empty (clean emulator images);
|
||||
// completeness is about unparsed lines, not row count.
|
||||
check(
|
||||
"third-party package listing reports complete coverage",
|
||||
packages.coverage === "complete",
|
||||
`${packages.packages.length} package(s)`,
|
||||
);
|
||||
const allPackages = await run("list_adb_packages", {
|
||||
serial,
|
||||
scope: "all",
|
||||
});
|
||||
if (allPackages !== null) {
|
||||
check(
|
||||
"selected device present with a kind inference",
|
||||
selected !== undefined &&
|
||||
["emulator", "physical", "unknown"].includes(selected.kind),
|
||||
`serial=${serial} kind=${selected?.kind} basis=${selected?.kind_basis}`,
|
||||
"full package inventory is non-empty",
|
||||
allPackages.coverage === "complete" && allPackages.packages.length > 0,
|
||||
`${allPackages.packages.length} package(s)`,
|
||||
);
|
||||
}
|
||||
if (pullCandidate === null && packages.packages.length > 0)
|
||||
pullCandidate = packages.packages[0].package_name;
|
||||
}
|
||||
|
||||
if (serial !== null) {
|
||||
const device = await run("inspect_adb_device", { serial });
|
||||
if (device !== null) {
|
||||
check(
|
||||
"device build identity projected",
|
||||
device.properties.some(
|
||||
(property) => property.name === "ro.build.version.sdk",
|
||||
),
|
||||
`sdk=${
|
||||
device.properties.find((p) => p.name === "ro.build.version.sdk")
|
||||
?.value
|
||||
} emulator_observed=${String(device.emulator_observed)}`,
|
||||
);
|
||||
}
|
||||
|
||||
// Observation tools: processes, window, display, settings, logcat.
|
||||
const processes = await run("list_adb_processes", { serial });
|
||||
if (processes !== null) {
|
||||
check(
|
||||
"process listing is non-empty with a header",
|
||||
processes.processes.length > 0 && typeof processes.columns === "string",
|
||||
`${processes.processes.length} process(es)`,
|
||||
);
|
||||
}
|
||||
const window = await run("inspect_adb_window", { serial });
|
||||
if (window !== null)
|
||||
check(
|
||||
"window focus observation completed",
|
||||
typeof window.focused_window === "string" ||
|
||||
window.focused_window === null,
|
||||
`focused_window=${String(window.focused_window).slice(0, 60)} (null is legitimate on headless devices)`,
|
||||
);
|
||||
const display = await run("inspect_adb_display", { serial });
|
||||
if (display !== null)
|
||||
check(
|
||||
"display reports a physical size",
|
||||
display.physical_size !== null &&
|
||||
display.physical_size.width > 0 &&
|
||||
display.physical_size.height > 0,
|
||||
`${display.physical_size?.width}x${display.physical_size?.height} @${String(display.physical_density)}`,
|
||||
);
|
||||
const setting = await run("read_adb_setting", {
|
||||
serial,
|
||||
namespace: "global",
|
||||
key: "adb_enabled",
|
||||
});
|
||||
if (setting !== null)
|
||||
check(
|
||||
"settings read returns the device's own value",
|
||||
setting.value === "1",
|
||||
`adb_enabled=${String(setting.value)}`,
|
||||
);
|
||||
const logcat = await run("read_adb_logcat", {
|
||||
serial,
|
||||
count: 20,
|
||||
buffer: "main",
|
||||
});
|
||||
if (logcat !== null)
|
||||
check(
|
||||
"logcat dump returns bounded lines",
|
||||
logcat.lines.length <= 20,
|
||||
`${logcat.lines.length} line(s), coverage=${logcat.coverage}`,
|
||||
);
|
||||
const features = await run("list_adb_features", { serial });
|
||||
if (features !== null)
|
||||
check(
|
||||
"feature inventory is non-empty",
|
||||
features.coverage === "complete" && features.features.length > 0,
|
||||
`${features.features.length} feature(s)`,
|
||||
);
|
||||
const services = await run("list_adb_services", { serial });
|
||||
if (services !== null)
|
||||
check(
|
||||
"service inventory is non-empty",
|
||||
services.coverage === "complete" && services.services.length > 0,
|
||||
`${services.services.length} service(s)`,
|
||||
);
|
||||
const directory = await run("list_adb_directory", {
|
||||
serial,
|
||||
device_path: "/data/local/tmp",
|
||||
});
|
||||
if (directory !== null)
|
||||
check(
|
||||
"directory listing completed",
|
||||
directory.coverage === "complete",
|
||||
`${directory.entries.length} entr(ies)`,
|
||||
);
|
||||
|
||||
const packages = await run("list_adb_packages", {
|
||||
serial,
|
||||
scope: "third_party",
|
||||
});
|
||||
let pullCandidate = options.pull ?? null;
|
||||
if (packages !== null) {
|
||||
// A third-party scope may legitimately be empty (clean emulator images);
|
||||
// completeness is about unparsed lines, not row count.
|
||||
check(
|
||||
"third-party package listing reports complete coverage",
|
||||
packages.coverage === "complete",
|
||||
`${packages.packages.length} package(s)`,
|
||||
);
|
||||
const allPackages = await run("list_adb_packages", {
|
||||
serial,
|
||||
scope: "all",
|
||||
});
|
||||
if (allPackages !== null) {
|
||||
check(
|
||||
"full package inventory is non-empty",
|
||||
allPackages.coverage === "complete" &&
|
||||
allPackages.packages.length > 0,
|
||||
`${allPackages.packages.length} package(s)`,
|
||||
);
|
||||
}
|
||||
if (pullCandidate === null && packages.packages.length > 0)
|
||||
pullCandidate = packages.packages[0].package_name;
|
||||
}
|
||||
|
||||
if (pullCandidate !== null) {
|
||||
const directory = await mkdtemp(join(tmpdir(), "rea-adb-verify-"));
|
||||
try {
|
||||
const pull = await run("pull_adb_package", {
|
||||
serial,
|
||||
package: pullCandidate,
|
||||
output_directory: directory,
|
||||
});
|
||||
if (pull !== null) {
|
||||
// Installed /data/app packages name their APKs base.apk and
|
||||
// split_*.apk; system packages keep arbitrary names, so the lane
|
||||
// checks a non-empty artifact set and verifies each file on disk.
|
||||
check(
|
||||
"pull returned a non-empty artifact set",
|
||||
pull.artifacts.length > 0,
|
||||
`${pull.artifacts.length} artifact(s), coverage=${pull.coverage}, roles=${pull.artifacts.map((a) => a.role).join(",")}`,
|
||||
);
|
||||
for (const artifact of pull.artifacts) {
|
||||
const bytes = await stat(artifact.local_path).then(
|
||||
(info) => info.size,
|
||||
);
|
||||
const digest = createHash("sha256")
|
||||
.update(await readFile(artifact.local_path))
|
||||
.digest("hex");
|
||||
check(
|
||||
`artifact digest matches on disk: ${artifact.file_name}`,
|
||||
bytes === artifact.bytes && digest === artifact.sha256,
|
||||
`${bytes} bytes`,
|
||||
);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
// File transfer: push one lane-owned file, verify both digests, pull it
|
||||
// back, then clean up the device copy through the same fixed argv surface.
|
||||
const transferRoot = await mkdtemp(join(tmpdir(), "rea-adb-transfer-"));
|
||||
if (pullCandidate !== null) {
|
||||
const directory = await mkdtemp(join(tmpdir(), "rea-adb-verify-"));
|
||||
try {
|
||||
const payload = join(transferRoot, "rea-verify.txt");
|
||||
const payloadBytes = "rea adb transfer verification\n";
|
||||
await import("node:fs/promises").then((fs) =>
|
||||
fs.writeFile(payload, payloadBytes),
|
||||
);
|
||||
const deviceTarget = `/data/local/tmp/rea-verify-${Date.now()}.txt`;
|
||||
const pushed = await run("push_adb_file", {
|
||||
const pull = await run("pull_adb_package", {
|
||||
serial,
|
||||
local_path: payload,
|
||||
device_path: deviceTarget,
|
||||
overwrite: false,
|
||||
package: pullCandidate,
|
||||
output_directory: directory,
|
||||
});
|
||||
if (pushed !== null) {
|
||||
if (pull !== null) {
|
||||
// Installed /data/app packages name their APKs base.apk and
|
||||
// split_*.apk; system packages keep arbitrary names, so the lane
|
||||
// checks a non-empty artifact set and verifies each file on disk.
|
||||
check(
|
||||
"push reports matching device-side digest",
|
||||
pushed.device_digest_source === "device_sha256sum" &&
|
||||
pushed.device_sha256 === pushed.sha256,
|
||||
`${pushed.bytes} bytes`,
|
||||
"pull returned a non-empty artifact set",
|
||||
pull.artifacts.length > 0,
|
||||
`${pull.artifacts.length} artifact(s), coverage=${pull.coverage}, roles=${pull.artifacts.map((a) => a.role).join(",")}`,
|
||||
);
|
||||
const pulled = await run("pull_adb_file", {
|
||||
serial,
|
||||
device_path: deviceTarget,
|
||||
output_directory: transferRoot,
|
||||
});
|
||||
if (pulled !== null)
|
||||
check(
|
||||
"pulled file digest matches the pushed digest",
|
||||
pulled.sha256 === pushed.sha256,
|
||||
`${pulled.bytes} bytes`,
|
||||
for (const artifact of pull.artifacts) {
|
||||
const bytes = await stat(artifact.local_path).then(
|
||||
(info) => info.size,
|
||||
);
|
||||
}
|
||||
const screenRoot = await mkdtemp(join(tmpdir(), "rea-adb-screen-"));
|
||||
try {
|
||||
const screen = await run("capture_adb_screen", {
|
||||
serial,
|
||||
output_directory: screenRoot,
|
||||
});
|
||||
if (screen !== null)
|
||||
const digest = createHash("sha256")
|
||||
.update(await readFile(artifact.local_path))
|
||||
.digest("hex");
|
||||
check(
|
||||
"screen capture is a sized PNG",
|
||||
screen.width !== null && screen.height !== null && screen.bytes > 0,
|
||||
`${screen.width}x${screen.height}, ${screen.bytes} bytes`,
|
||||
`artifact digest matches on disk: ${artifact.file_name}`,
|
||||
bytes === artifact.bytes && digest === artifact.sha256,
|
||||
`${bytes} bytes`,
|
||||
);
|
||||
} finally {
|
||||
await rm(screenRoot, { recursive: true, force: true });
|
||||
}
|
||||
if (options.pull !== null) {
|
||||
const details = await run("inspect_adb_package", {
|
||||
serial,
|
||||
package: options.pull,
|
||||
});
|
||||
if (details !== null)
|
||||
check(
|
||||
"dumpsys package projection completed",
|
||||
details.coverage === "complete",
|
||||
`versionCode=${String(details.version_code)}`,
|
||||
);
|
||||
}
|
||||
if (options.installApk !== null && options.installApk !== undefined) {
|
||||
const probePackage = "com.rea.adb.probe";
|
||||
const installedProbe = await run("install_adb_package", {
|
||||
serial,
|
||||
apk_path: options.installApk,
|
||||
replace: false,
|
||||
});
|
||||
if (installedProbe !== null) {
|
||||
check(
|
||||
"install reports the APK digest",
|
||||
typeof installedProbe.sha256 === "string" &&
|
||||
installedProbe.sha256.length === 64,
|
||||
`${installedProbe.bytes} bytes`,
|
||||
);
|
||||
const resolved = await run("resolve_adb_packages", {
|
||||
serial,
|
||||
query: "rea.adb.probe",
|
||||
});
|
||||
if (resolved !== null)
|
||||
check(
|
||||
"resolve finds the installed probe uniquely",
|
||||
resolved.matches.length === 1 &&
|
||||
resolved.matches[0]?.package_name === probePackage,
|
||||
`${resolved.matches.length} match(es)`,
|
||||
);
|
||||
const started = await run("start_adb_app", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (started !== null)
|
||||
check(
|
||||
"app start resolves and launches the launcher activity",
|
||||
typeof started.component === "string" &&
|
||||
started.component.startsWith(probePackage),
|
||||
String(started.component),
|
||||
);
|
||||
const observedProcesses = await run("list_adb_processes", { serial });
|
||||
if (observedProcesses !== null)
|
||||
check(
|
||||
"started app appears in the process listing",
|
||||
observedProcesses.processes.some(
|
||||
(process) => process.name === probePackage,
|
||||
),
|
||||
);
|
||||
const stopped = await run("stop_adb_app", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (stopped !== null)
|
||||
check(
|
||||
"force-stop completes the dynamic-analysis run",
|
||||
stopped.package_name === probePackage,
|
||||
);
|
||||
const removed = await run("uninstall_adb_package", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (removed !== null)
|
||||
check(
|
||||
"uninstall completes the lifecycle",
|
||||
removed.package_name === probePackage,
|
||||
);
|
||||
const afterRemoval = await run("resolve_adb_packages", {
|
||||
serial,
|
||||
query: "rea.adb.probe",
|
||||
});
|
||||
if (afterRemoval !== null)
|
||||
check(
|
||||
"resolve reports zero matches after removal",
|
||||
afterRemoval.matches.length === 0,
|
||||
);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
await rm(transferRoot, { recursive: true, force: true });
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
} catch (cause) {
|
||||
primaryFailure = cause;
|
||||
|
||||
// File transfer: push one lane-owned file, verify both digests, pull it
|
||||
// back, then clean up the device copy through the same fixed argv surface.
|
||||
const transferRoot = await mkdtemp(join(tmpdir(), "rea-adb-transfer-"));
|
||||
try {
|
||||
const payload = join(transferRoot, "rea-verify.txt");
|
||||
const payloadBytes = "rea adb transfer verification\n";
|
||||
await import("node:fs/promises").then((fs) =>
|
||||
fs.writeFile(payload, payloadBytes),
|
||||
);
|
||||
const deviceTarget = `/data/local/tmp/rea-verify-${Date.now()}.txt`;
|
||||
const pushed = await run("push_adb_file", {
|
||||
serial,
|
||||
local_path: payload,
|
||||
device_path: deviceTarget,
|
||||
overwrite: false,
|
||||
});
|
||||
if (pushed !== null) {
|
||||
check(
|
||||
"push reports matching device-side digest",
|
||||
pushed.device_digest_source === "device_sha256sum" &&
|
||||
pushed.device_sha256 === pushed.sha256,
|
||||
`${pushed.bytes} bytes`,
|
||||
);
|
||||
const pulled = await run("pull_adb_file", {
|
||||
serial,
|
||||
device_path: deviceTarget,
|
||||
output_directory: transferRoot,
|
||||
});
|
||||
if (pulled !== null)
|
||||
check(
|
||||
"pulled file digest matches the pushed digest",
|
||||
pulled.sha256 === pushed.sha256,
|
||||
`${pulled.bytes} bytes`,
|
||||
);
|
||||
}
|
||||
const screenRoot = await mkdtemp(join(tmpdir(), "rea-adb-screen-"));
|
||||
try {
|
||||
const screen = await run("capture_adb_screen", {
|
||||
serial,
|
||||
output_directory: screenRoot,
|
||||
});
|
||||
if (screen !== null)
|
||||
check(
|
||||
"screen capture is a sized PNG",
|
||||
screen.width !== null && screen.height !== null && screen.bytes > 0,
|
||||
`${screen.width}x${screen.height}, ${screen.bytes} bytes`,
|
||||
);
|
||||
} finally {
|
||||
await rm(screenRoot, { recursive: true, force: true });
|
||||
}
|
||||
if (options.pull !== null) {
|
||||
const details = await run("inspect_adb_package", {
|
||||
serial,
|
||||
package: options.pull,
|
||||
});
|
||||
if (details !== null)
|
||||
check(
|
||||
"dumpsys package projection completed",
|
||||
details.coverage === "complete",
|
||||
`versionCode=${String(details.version_code)}`,
|
||||
);
|
||||
}
|
||||
if (options.installApk !== null && options.installApk !== undefined) {
|
||||
const probePackage = "com.rea.adb.probe";
|
||||
const installedProbe = await run("install_adb_package", {
|
||||
serial,
|
||||
apk_path: options.installApk,
|
||||
replace: false,
|
||||
});
|
||||
if (installedProbe !== null) {
|
||||
check(
|
||||
"install reports the APK digest",
|
||||
typeof installedProbe.sha256 === "string" &&
|
||||
installedProbe.sha256.length === 64,
|
||||
`${installedProbe.bytes} bytes`,
|
||||
);
|
||||
const resolved = await run("resolve_adb_packages", {
|
||||
serial,
|
||||
query: "rea.adb.probe",
|
||||
});
|
||||
if (resolved !== null)
|
||||
check(
|
||||
"resolve finds the installed probe uniquely",
|
||||
resolved.matches.length === 1 &&
|
||||
resolved.matches[0]?.package_name === probePackage,
|
||||
`${resolved.matches.length} match(es)`,
|
||||
);
|
||||
const started = await run("start_adb_app", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (started !== null)
|
||||
check(
|
||||
"app start resolves and launches the launcher activity",
|
||||
typeof started.component === "string" &&
|
||||
started.component.startsWith(probePackage),
|
||||
String(started.component),
|
||||
);
|
||||
const observedProcesses = await run("list_adb_processes", { serial });
|
||||
if (observedProcesses !== null)
|
||||
check(
|
||||
"started app appears in the process listing",
|
||||
observedProcesses.processes.some(
|
||||
(process) => process.name === probePackage,
|
||||
),
|
||||
);
|
||||
const stopped = await run("stop_adb_app", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (stopped !== null)
|
||||
check(
|
||||
"force-stop completes the dynamic-analysis run",
|
||||
stopped.package_name === probePackage,
|
||||
);
|
||||
const removed = await run("uninstall_adb_package", {
|
||||
serial,
|
||||
package: probePackage,
|
||||
});
|
||||
if (removed !== null)
|
||||
check(
|
||||
"uninstall completes the lifecycle",
|
||||
removed.package_name === probePackage,
|
||||
);
|
||||
const afterRemoval = await run("resolve_adb_packages", {
|
||||
serial,
|
||||
query: "rea.adb.probe",
|
||||
});
|
||||
if (afterRemoval !== null)
|
||||
check(
|
||||
"resolve reports zero matches after removal",
|
||||
afterRemoval.matches.length === 0,
|
||||
);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
await rm(transferRoot, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
|
||||
let cleanupFailure;
|
||||
try {
|
||||
await closeVerifierResources([() => provider.close()], primaryFailure);
|
||||
} catch (cause) {
|
||||
cleanupFailure = cause;
|
||||
await provider.close();
|
||||
} catch {
|
||||
// The provider owns nothing long-lived; closing is best-effort.
|
||||
}
|
||||
|
||||
if (primaryFailure !== undefined || cleanupFailure !== undefined) {
|
||||
const causes =
|
||||
cleanupFailure instanceof AggregateError
|
||||
? cleanupFailure.errors
|
||||
: [cleanupFailure ?? primaryFailure];
|
||||
process.stderr.write(
|
||||
`ADB device verification failed: ${causes.map((cause) => (cause instanceof Error ? cause.message : String(cause))).join("; ")}\n`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
} else if (failures > 0) {
|
||||
if (failures > 0) {
|
||||
process.stdout.write(`\n${failures} check(s) failed\n`);
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
process.stdout.write("\nall adb device checks passed\n");
|
||||
process.exit(1);
|
||||
}
|
||||
process.stdout.write("\nall adb device checks passed\n");
|
||||
|
||||
function parseArguments(argv) {
|
||||
const parsed = { help: false, serial: null, pull: null, installApk: null };
|
||||
|
||||
+14
-41
@@ -1,6 +1,6 @@
|
||||
import assert from "node:assert/strict";
|
||||
import { execFile } from "node:child_process";
|
||||
import { mkdtemp, readdir, readFile, rmdir } from "node:fs/promises";
|
||||
import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join, resolve } from "node:path";
|
||||
import { promisify } from "node:util";
|
||||
@@ -8,9 +8,7 @@ import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { toolContract } from "../dist/contracts/toolContracts.js";
|
||||
import { hashStableFile } from "../dist/filesystem/StableFileHash.js";
|
||||
import { OwnedRegularFileCleanupFailure } from "../dist/filesystem/RegularFile.js";
|
||||
import { mcpTextValue } from "./lib/mcp-verifier-results.mjs";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
|
||||
const options = parseArguments(process.argv.slice(2));
|
||||
if (options.help) {
|
||||
@@ -41,17 +39,6 @@ Object.assign(environment, {
|
||||
TEMP: root,
|
||||
});
|
||||
const client = new Client({ name: "flutter-verifier", version: "1" });
|
||||
let primaryError;
|
||||
const hashOwners = new Map();
|
||||
const hashOwned = async (...args) => {
|
||||
try {
|
||||
return await hashStableFile(...args);
|
||||
} catch (cause) {
|
||||
if (cause instanceof OwnedRegularFileCleanupFailure)
|
||||
hashOwners.set(cause.owner, cause.path);
|
||||
throw cause;
|
||||
}
|
||||
};
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
@@ -62,7 +49,7 @@ const execute = promisify(execFile);
|
||||
try {
|
||||
await client.connect(transport);
|
||||
const apk = resolve(options.apk);
|
||||
const identity = await hashOwned(apk);
|
||||
const identity = await hashStableFile(apk);
|
||||
const identified = await run("identify_flutter_build", { path: apk });
|
||||
assert.deepEqual(identified.target, { path: apk, ...identity });
|
||||
assert.equal(identified.flutter_detected, true);
|
||||
@@ -189,46 +176,32 @@ try {
|
||||
const negative = await run("identify_flutter_build", { path: plain });
|
||||
assert.deepEqual(negative.target, {
|
||||
path: plain,
|
||||
...(await hashOwned(plain)),
|
||||
...(await hashStableFile(plain)),
|
||||
});
|
||||
assert.equal(negative.flutter_detected, false);
|
||||
assert.equal(negative.coverage, "complete");
|
||||
}
|
||||
assert.deepEqual(
|
||||
await hashOwned(apk),
|
||||
await hashStableFile(apk),
|
||||
identity,
|
||||
"Verification must preserve its input",
|
||||
);
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
const cleanup = [];
|
||||
for (const [owner, path] of hashOwners) {
|
||||
cleanup.push(async () => {
|
||||
try {
|
||||
await owner.close();
|
||||
hashOwners.delete(owner);
|
||||
} catch (cause) {
|
||||
throw new Error(`Could not close hash file handle for ${path}`, {
|
||||
cause,
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
cleanup.push(async () => {
|
||||
await closeVerifierResources([
|
||||
() => client.close(),
|
||||
() => transport.close(),
|
||||
]);
|
||||
// Server shutdown retries retained provider cleanup and must settle before success.
|
||||
try {
|
||||
try {
|
||||
await client.close();
|
||||
} finally {
|
||||
await transport.close();
|
||||
}
|
||||
assert.deepEqual(
|
||||
await readdir(root),
|
||||
[],
|
||||
`Provider snapshots remain under ${root}`,
|
||||
);
|
||||
await rmdir(root);
|
||||
});
|
||||
await closeVerifierResources(cleanup, primaryError);
|
||||
} finally {
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
}
|
||||
process.stdout.write(
|
||||
"all asserted Flutter CLI/MCP checks passed; unverified facets are reported above\n",
|
||||
|
||||
@@ -5,11 +5,6 @@ import { tmpdir } from "node:os";
|
||||
import { join, resolve, sep } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import Ajv2020 from "ajv/dist/2020.js";
|
||||
import {
|
||||
schemaArrays,
|
||||
schemaChildren,
|
||||
schemaMaps,
|
||||
} from "../dist/contracts/inputSchemaPresentation.js";
|
||||
import {
|
||||
TOOL_CONTRACTS,
|
||||
toolContract,
|
||||
@@ -22,8 +17,6 @@ const repo = fileURLToPath(new URL("..", import.meta.url));
|
||||
const runtimeRoot = process.env.REA_VERIFY_RUNTIME_ROOT ?? repo;
|
||||
const command = process.env.REA_VERIFY_GEMINI_COMMAND ?? "gemini";
|
||||
const mode = process.argv[2] ?? "call";
|
||||
const schemaProfile = process.env.REA_VERIFY_GEMINI_SCHEMA_PROFILE ?? "full";
|
||||
assert(["full", "compact"].includes(schemaProfile));
|
||||
// npm installs of Gemini CLI provide a JavaScript entry point; on Windows only a gemini.cmd shim reaches
|
||||
// PATH, which Node does not spawn without a shell, so a selected .js entry runs under this Node. It is
|
||||
// resolved once, because the preflight runs from the caller's directory and the client from the workspace.
|
||||
@@ -67,7 +60,6 @@ const environment = {
|
||||
GEMINI_CLI_NO_RELAUNCH: "1",
|
||||
GEMINI_CLI_TRUST_WORKSPACE: "true",
|
||||
REA_PROCESS_RUN_ID: verifier.run_id,
|
||||
REA_MCP_INPUT_SCHEMA_PROFILE: schemaProfile,
|
||||
};
|
||||
let clientVersion;
|
||||
try {
|
||||
@@ -169,43 +161,8 @@ let skillRequested = false;
|
||||
let finalSeen = false;
|
||||
let catalogSize = 0;
|
||||
let schemasChecked = 0;
|
||||
let examplesChecked = 0;
|
||||
let artifactDigest;
|
||||
const schemaValidator = new Ajv2020({ strict: false, validateFormats: false });
|
||||
const booleanLiteralPath = (schema, path = "$", seen = new Set()) => {
|
||||
if (!schema || typeof schema !== "object" || seen.has(schema))
|
||||
return undefined;
|
||||
seen.add(schema);
|
||||
for (const [key, child] of Object.entries(schema)) {
|
||||
const childPath = `${path}.${key}`;
|
||||
if (key === "const" && typeof child === "boolean") return childPath;
|
||||
if (
|
||||
key === "enum" &&
|
||||
Array.isArray(child) &&
|
||||
child.some((item) => typeof item === "boolean")
|
||||
)
|
||||
return childPath;
|
||||
const schemaChildrenAtKey =
|
||||
schemaMaps.has(key) &&
|
||||
child &&
|
||||
typeof child === "object" &&
|
||||
!Array.isArray(child)
|
||||
? Object.entries(child).map(([name, item]) => [
|
||||
`${childPath}.${name}`,
|
||||
item,
|
||||
])
|
||||
: schemaArrays.has(key) && Array.isArray(child)
|
||||
? child.map((item, index) => [`${childPath}[${index}]`, item])
|
||||
: schemaChildren.has(key)
|
||||
? [[childPath, child]]
|
||||
: [];
|
||||
for (const [nestedPath, nested] of schemaChildrenAtKey) {
|
||||
const found = booleanLiteralPath(nested, nestedPath, seen);
|
||||
if (found !== undefined) return found;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
const extractEvidence = (value) => {
|
||||
if (typeof value === "string") {
|
||||
if (
|
||||
@@ -269,22 +226,6 @@ const fixture = await createGeminiModelFixture({
|
||||
schemaValidator.validateSchema(tool.parametersJsonSchema),
|
||||
`${tool.name}: invalid advertised JSON Schema: ${JSON.stringify(schemaValidator.errors)}`,
|
||||
);
|
||||
const booleanLiteral = booleanLiteralPath(tool.parametersJsonSchema);
|
||||
assert.equal(
|
||||
booleanLiteral,
|
||||
undefined,
|
||||
`${tool.name}: Gemini SDK declaration retains a boolean const/enum at ${booleanLiteral}`,
|
||||
);
|
||||
const name = tool.name.slice(prefix.length);
|
||||
const contract = toolContract(name);
|
||||
const validate = schemaValidator.compile(tool.parametersJsonSchema);
|
||||
for (const example of contract.examples) {
|
||||
assert(
|
||||
validate(example.input),
|
||||
`${tool.name}: Gemini SDK declaration rejects canonical example ${example.title}: ${JSON.stringify(schemaValidator.errors)}`,
|
||||
);
|
||||
examplesChecked++;
|
||||
}
|
||||
schemasChecked++;
|
||||
}
|
||||
}
|
||||
@@ -415,9 +356,6 @@ try {
|
||||
client: "Gemini CLI",
|
||||
clientVersion,
|
||||
mode,
|
||||
schemaProfile,
|
||||
schemasChecked,
|
||||
examplesChecked,
|
||||
passed: failure === undefined,
|
||||
artifacts: lab,
|
||||
runtimeRoot,
|
||||
|
||||
@@ -1,182 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
// Compile the packaged Ghidra bridge sources against an existing Ghidra
|
||||
// installation's jars. Ghidra's script provider compiles the whole bridge
|
||||
// directory when a session starts, so one unresolved symbol disables every
|
||||
// operation and surfaces only after import and auto-analysis. This check
|
||||
// reports the same javac diagnostics without launching Ghidra or selecting,
|
||||
// importing or executing a target.
|
||||
import { spawnSync } from "node:child_process";
|
||||
import { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { dirname, join, relative, resolve } from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
// The pinned Node toolchain strips types from these dependency-free owners;
|
||||
// this preflight therefore uses runtime facts without needing npm ci or a build.
|
||||
import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
|
||||
import { parseGhidraJavaProperties } from "../src/ghidra/GhidraJavaProperties.ts";
|
||||
import {
|
||||
SUPPORTED_GHIDRA_VERSION,
|
||||
SUPPORTED_GHIDRA_JAVA_MAJOR,
|
||||
ghidraReleaseAccepted,
|
||||
ghidraReleaseLine,
|
||||
} from "../src/ghidra/GhidraReleasePolicy.ts";
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
if (
|
||||
args.length > 1 ||
|
||||
(args.length === 1 &&
|
||||
!["--check-sdk-pin", "--verified-sdk"].includes(args[0]))
|
||||
)
|
||||
fail(
|
||||
"Usage: verify-ghidra-bridge-sources.mjs [--check-sdk-pin|--verified-sdk]",
|
||||
);
|
||||
if (args[0] === "--check-sdk-pin") {
|
||||
let url;
|
||||
try {
|
||||
url = new URL(process.env.GHIDRA_RELEASE_URL);
|
||||
} catch {
|
||||
fail("GHIDRA_RELEASE_URL must name the checksum-pinned official release");
|
||||
}
|
||||
const prefix = `/NationalSecurityAgency/ghidra/releases/download/Ghidra_${SUPPORTED_GHIDRA_VERSION}_build/ghidra_${SUPPORTED_GHIDRA_VERSION}_PUBLIC_`;
|
||||
if (
|
||||
url.origin !== "https://github.com" ||
|
||||
url.username ||
|
||||
url.password ||
|
||||
url.search ||
|
||||
url.hash ||
|
||||
!url.pathname.startsWith(prefix) ||
|
||||
!url.pathname.endsWith(".zip") ||
|
||||
!/^[a-f0-9]{64}$/iu.test(process.env.GHIDRA_RELEASE_SHA256 ?? "")
|
||||
)
|
||||
fail(
|
||||
`SDK URL and SHA256 must match verified Ghidra ${SUPPORTED_GHIDRA_VERSION}`,
|
||||
);
|
||||
console.log(`GHIDRA_JAVA_MAJOR=${SUPPORTED_GHIDRA_JAVA_MAJOR}`);
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
|
||||
const bridge = join(root, "bridge/ghidra");
|
||||
const install = process.env.GHIDRA_INSTALL_DIR;
|
||||
if (!install)
|
||||
fail(
|
||||
`Set GHIDRA_INSTALL_DIR to an existing Ghidra ${ghidraReleaseLine()} installation (verified with ${SUPPORTED_GHIDRA_VERSION}). REA does not install Ghidra.`,
|
||||
);
|
||||
const properties = await readFile(
|
||||
join(install, "Ghidra/application.properties"),
|
||||
"latin1",
|
||||
).catch((cause) =>
|
||||
fail(
|
||||
`GHIDRA_INSTALL_DIR has no readable Ghidra/application.properties: ${cause.message}`,
|
||||
),
|
||||
);
|
||||
const parsedProperties = parseGhidraJavaProperties(properties);
|
||||
if (!parsedProperties.ok) fail(parsedProperties.error);
|
||||
const version = parsedProperties.value.get("application.version");
|
||||
if (!ghidraReleaseAccepted(version))
|
||||
fail(
|
||||
`Bridge sources require Ghidra ${ghidraReleaseLine()} (verified with ${SUPPORTED_GHIDRA_VERSION}). Observed application.version=${version === undefined ? "missing" : JSON.stringify(version)}.`,
|
||||
);
|
||||
if (args[0] === "--verified-sdk" && version !== SUPPORTED_GHIDRA_VERSION)
|
||||
fail(
|
||||
`CI SDK must be verified Ghidra ${SUPPORTED_GHIDRA_VERSION}; observed ${JSON.stringify(version)}`,
|
||||
);
|
||||
const sourceNames = (await readdir(bridge, { withFileTypes: true }))
|
||||
.filter((entry) => entry.isFile() && entry.name.endsWith(".java"))
|
||||
.map((entry) => entry.name);
|
||||
for (const name of Object.values(GHIDRA_BRIDGE_SOURCES))
|
||||
if (!sourceNames.includes(name))
|
||||
fail(`Required Ghidra bridge source is missing: bridge/ghidra/${name}`);
|
||||
const requiredNames = new Set(Object.values(GHIDRA_BRIDGE_SOURCES));
|
||||
const unregistered = sourceNames.filter((name) => !requiredNames.has(name));
|
||||
if (unregistered.length)
|
||||
fail(
|
||||
`Ghidra bridge sources absent from the manifest: ${unregistered.join(", ")}`,
|
||||
);
|
||||
const sources = sourceNames
|
||||
.map((name) => relative(root, join(bridge, name)))
|
||||
.sort();
|
||||
|
||||
const javac = process.env.JAVA_HOME
|
||||
? join(process.env.JAVA_HOME, "bin", "javac")
|
||||
: "javac";
|
||||
const banner = run(javac, ["-version"]);
|
||||
if (banner.error || banner.status !== 0)
|
||||
fail(`javac is unavailable: ${banner.error?.message ?? output(banner)}`);
|
||||
const major = Number(/^javac (\d+)/mu.exec(output(banner))?.[1]);
|
||||
if (!Number.isInteger(major) || major < SUPPORTED_GHIDRA_JAVA_MAJOR)
|
||||
fail(
|
||||
`Ghidra ${ghidraReleaseLine()} compiles bridge scripts with Java ${SUPPORTED_GHIDRA_JAVA_MAJOR} or newer. Observed: ${output(banner) || "no version"}. REA does not install or upgrade Java.`,
|
||||
);
|
||||
|
||||
const jars = (
|
||||
await readdir(join(install, "Ghidra"), {
|
||||
recursive: true,
|
||||
withFileTypes: true,
|
||||
})
|
||||
)
|
||||
.filter((entry) => entry.isFile() && entry.name.endsWith(".jar"))
|
||||
.map((entry) => join(entry.parentPath, entry.name))
|
||||
.sort();
|
||||
if (jars.length === 0) fail(`No jars found under ${join(install, "Ghidra")}.`);
|
||||
|
||||
const scratch = await mkdtemp(join(tmpdir(), "rea-ghidra-bridge-"));
|
||||
try {
|
||||
// An argument file keeps the jar class path below Windows' command length.
|
||||
const argumentFile = join(scratch, "javac.args");
|
||||
await writeFile(
|
||||
argumentFile,
|
||||
[
|
||||
"-proc:none",
|
||||
"-encoding",
|
||||
"UTF-8",
|
||||
"--release",
|
||||
String(SUPPORTED_GHIDRA_JAVA_MAJOR),
|
||||
"-cp",
|
||||
jars.join(process.platform === "win32" ? ";" : ":"),
|
||||
"-d",
|
||||
join(scratch, "classes"),
|
||||
...sources,
|
||||
]
|
||||
.map((s) => `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`)
|
||||
.join("\n"),
|
||||
);
|
||||
// Sources are repository-relative, so diagnostics name bridge/ghidra/<file>:<line>.
|
||||
const result = run(javac, ["-J-Xmx1g", `@${argumentFile}`]);
|
||||
if (result.error || result.status !== 0) {
|
||||
// Set the status instead of exiting so the scratch directory is removed.
|
||||
process.stderr.write(
|
||||
`${output(result) || result.error?.message || "javac failed"}\nGhidra ${version} could not compile the packaged bridge sources; the provider would fail at session start.\n`,
|
||||
);
|
||||
process.exitCode = 1;
|
||||
} else {
|
||||
console.log(
|
||||
JSON.stringify({
|
||||
ghidra_version: version,
|
||||
javac: output(banner),
|
||||
class_path_jars: jars.length,
|
||||
sources,
|
||||
}),
|
||||
);
|
||||
}
|
||||
} finally {
|
||||
await rm(scratch, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
function run(command, args) {
|
||||
return spawnSync(command, args, {
|
||||
cwd: root,
|
||||
encoding: "utf8",
|
||||
timeout: 300_000,
|
||||
maxBuffer: 16 * 1024 * 1024,
|
||||
});
|
||||
}
|
||||
|
||||
function output(result) {
|
||||
return `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
|
||||
}
|
||||
|
||||
function fail(message) {
|
||||
process.stderr.write(`${message}\n`);
|
||||
process.exit(1);
|
||||
}
|
||||
@@ -2,7 +2,7 @@ import { rm } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
import { pathToFileURL } from "node:url";
|
||||
|
||||
import { exec, execNpm, json, run } from "./lib/verify-package-core.mjs";
|
||||
import { exec, json, run } from "./lib/verify-package-core.mjs";
|
||||
|
||||
/** Install the packed CLI globally with and without optional dependencies and verify PTY degradation. */
|
||||
export async function verifyPackageInstall({
|
||||
@@ -11,7 +11,8 @@ export async function verifyPackageInstall({
|
||||
workspace,
|
||||
environment,
|
||||
}) {
|
||||
await execNpm(
|
||||
await exec(
|
||||
"npm",
|
||||
[
|
||||
"install",
|
||||
"--global",
|
||||
@@ -52,7 +53,8 @@ export async function verifyPackageInstall({
|
||||
`packaged PTY backend failed without lifecycle scripts: ${JSON.stringify(processCaptureCapability)}`,
|
||||
);
|
||||
const noOptionalPrefix = join(workspace, "prefix-no-optional");
|
||||
await execNpm(
|
||||
await exec(
|
||||
"npm",
|
||||
[
|
||||
"install",
|
||||
"--global",
|
||||
@@ -106,7 +108,7 @@ export async function verifyPackageInstall({
|
||||
const verifyInstalledPackageCanRepack = async (prefix, environment) => {
|
||||
const installedPackageRoot = join(prefix, "lib/node_modules/rea-agents");
|
||||
const repackedTarball = (
|
||||
await execNpm(["pack", "--silent"], {
|
||||
await exec("npm", ["pack", "--silent"], {
|
||||
cwd: installedPackageRoot,
|
||||
env: environment,
|
||||
})
|
||||
|
||||
@@ -2,7 +2,7 @@ import { mkdir } from "node:fs/promises";
|
||||
import { join } from "node:path";
|
||||
import { CATALOG_IDENTITY } from "../dist/catalogIdentity.js";
|
||||
|
||||
import { exec, execNpm } from "./lib/verify-package-core.mjs";
|
||||
import { exec } from "./lib/verify-package-core.mjs";
|
||||
import { verifyPackedBridge } from "./verify-packed-bridge.mjs";
|
||||
|
||||
/** Create a tarball and assert production packaging constraints. */
|
||||
@@ -12,15 +12,16 @@ export async function verifyPackagePack({ root, workspace }) {
|
||||
const tarball = join(
|
||||
packDirectory,
|
||||
(
|
||||
await execNpm(["pack", "--silent", "--pack-destination", packDirectory], {
|
||||
cwd: root,
|
||||
})
|
||||
await exec(
|
||||
"npm",
|
||||
["pack", "--silent", "--pack-destination", packDirectory],
|
||||
{
|
||||
cwd: root,
|
||||
},
|
||||
)
|
||||
).stdout.trim(),
|
||||
);
|
||||
const listing = (await exec("tar", ["-tf", tarball])).stdout;
|
||||
// A bare LF identifies LF output; preceding CRs then belong to filenames.
|
||||
const lineEnding = /(^|[^\r])\n/u.test(listing) ? "\n" : "\r\n";
|
||||
const packedFiles = listing.split(lineEnding);
|
||||
const packedFiles = (await exec("tar", ["-tf", tarball])).stdout.split("\n");
|
||||
const packedManifest = JSON.parse(
|
||||
(await exec("tar", ["-xOf", tarball, "package/package.json"])).stdout,
|
||||
);
|
||||
|
||||
@@ -28,7 +28,6 @@ import { fileURLToPath, pathToFileURL } from "node:url";
|
||||
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { execNpm } from "./lib/verify-package-core.mjs";
|
||||
|
||||
if (process.platform !== "win32" || process.arch !== "x64")
|
||||
throw new Error(
|
||||
@@ -83,10 +82,15 @@ let packageRoot = resolve(packageRootArgument ?? ".");
|
||||
// package roots support an already-installed artifact without a second install.
|
||||
if (packageRootArgument === undefined) {
|
||||
try {
|
||||
const npmEntry =
|
||||
process.env.npm_execpath ??
|
||||
join(dirname(process.execPath), "node_modules/npm/bin/npm-cli.js");
|
||||
const packed = JSON.parse(
|
||||
(
|
||||
await execNpm(
|
||||
await exec(
|
||||
process.execPath,
|
||||
[
|
||||
npmEntry,
|
||||
"pack",
|
||||
"--json",
|
||||
"--ignore-scripts",
|
||||
@@ -103,8 +107,10 @@ if (packageRootArgument === undefined) {
|
||||
"The package lane must produce one artifact.",
|
||||
);
|
||||
const prefix = join(workspace, "installed");
|
||||
await execNpm(
|
||||
await exec(
|
||||
process.execPath,
|
||||
[
|
||||
npmEntry,
|
||||
"install",
|
||||
"--prefix",
|
||||
prefix,
|
||||
|
||||
@@ -2,15 +2,12 @@
|
||||
import { join } from "node:path";
|
||||
import { mkdir } from "node:fs/promises";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
import { exec, execNpm } from "./lib/verify-package-core.mjs";
|
||||
import { WABT_WORKFLOW_TIMEOUT_MS } from "./lib/wabt-verifier-timeouts.mjs";
|
||||
import { exec } from "./lib/verify-package-core.mjs";
|
||||
import { verifyPackagePack } from "./verify-package-pack.mjs";
|
||||
|
||||
const root = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-wabt-package-verifier-",
|
||||
});
|
||||
let primaryError;
|
||||
try {
|
||||
const { tarball } = await verifyPackagePack({
|
||||
root: process.cwd(),
|
||||
@@ -26,7 +23,8 @@ try {
|
||||
XDG_CONFIG_HOME: join(home, ".config"),
|
||||
XDG_CACHE_HOME: join(home, ".cache"),
|
||||
};
|
||||
await execNpm(
|
||||
await exec(
|
||||
"npm",
|
||||
[
|
||||
"install",
|
||||
"--global",
|
||||
@@ -51,16 +49,9 @@ try {
|
||||
const verified = await exec(
|
||||
process.execPath,
|
||||
["scripts/verify-wasm-artifact.mjs", entrypoint, "--require-tools"],
|
||||
{
|
||||
env: environment,
|
||||
timeout: WABT_WORKFLOW_TIMEOUT_MS,
|
||||
maxBuffer: 4 * 1024 * 1024,
|
||||
},
|
||||
{ env: environment, timeout: 180_000, maxBuffer: 4 * 1024 * 1024 },
|
||||
);
|
||||
process.stdout.write(verified.stdout);
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources([() => root.close()], primaryError);
|
||||
await root.close();
|
||||
}
|
||||
@@ -1,20 +1,21 @@
|
||||
import { execFile } from "node:child_process";
|
||||
import { join } from "node:path";
|
||||
import { promisify } from "node:util";
|
||||
import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
|
||||
|
||||
const exec = promisify(execFile);
|
||||
const packedHopperBridge = "package/bridge/hopper_bridge.py";
|
||||
const packedCutterBridge = "package/bridge/cutter/rea_bridge.py";
|
||||
const packedGhidraBridge = "package/bridge/ghidra/ReaGhidraBridge.java";
|
||||
const packedGhidraActivator =
|
||||
"package/bridge/ghidra/ReaGhidraBundleActivator.java";
|
||||
|
||||
/** Check shipped bridge files; real-provider lanes verify runtime behavior. */
|
||||
export async function verifyPackedBridge({ workspace, tarball, packedFiles }) {
|
||||
for (const path of [
|
||||
packedHopperBridge,
|
||||
packedCutterBridge,
|
||||
...Object.values(GHIDRA_BRIDGE_SOURCES).map(
|
||||
(name) => `package/bridge/ghidra/${name}`,
|
||||
),
|
||||
packedGhidraBridge,
|
||||
packedGhidraActivator,
|
||||
]) {
|
||||
if (!packedFiles.includes(path)) throw new Error(`package omitted ${path}`);
|
||||
}
|
||||
|
||||
@@ -12,7 +12,6 @@ import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { Ajv2020 } from "ajv/dist/2020.js";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
if (process.platform !== "linux")
|
||||
@@ -107,7 +106,6 @@ const expectedAddressSpace = Math.min(
|
||||
.map((value) => (value === "unlimited" ? Infinity : Number(value))),
|
||||
);
|
||||
|
||||
let primaryError;
|
||||
try {
|
||||
await writeFile(path, source);
|
||||
await writeFile(bluetooth, bluetoothSource);
|
||||
@@ -265,27 +263,6 @@ try {
|
||||
assert.ok(pcapAjv.validateSchema(pcapTool.inputSchema));
|
||||
assert.ok(pcapAjv.validateSchema(pcapTool.outputSchema));
|
||||
for (const capturePath of [path, bluetooth]) {
|
||||
const capinfosOutput = (
|
||||
await execute(
|
||||
process.env.REA_CAPINFOS_COMMAND ?? "capinfos",
|
||||
["-M", "--", capturePath],
|
||||
{
|
||||
env: { ...environment, LC_ALL: "C", LANG: "C" },
|
||||
timeout: 60000,
|
||||
maxBuffer: 64 * 1024,
|
||||
},
|
||||
)
|
||||
).stdout;
|
||||
const expectedCaptureStart =
|
||||
/^(?:Earliest|First) packet time:[ \t]*(.+)$/mu
|
||||
.exec(capinfosOutput)?.[1]
|
||||
?.trim() ?? null;
|
||||
const expectedCaptureEnd =
|
||||
/^(?:Latest|Last) packet time:[ \t]*(.+)$/mu
|
||||
.exec(capinfosOutput)?.[1]
|
||||
?.trim() ?? null;
|
||||
assert.ok(expectedCaptureStart, capinfosOutput);
|
||||
assert.ok(expectedCaptureEnd, capinfosOutput);
|
||||
const response = await client.callTool({
|
||||
name: pcapTool.name,
|
||||
arguments: { path: capturePath, detail: "summary" },
|
||||
@@ -296,27 +273,12 @@ try {
|
||||
pcapAjv.errorsText(),
|
||||
);
|
||||
const summary = parseEvidence(response.structuredContent).normalized_result;
|
||||
assert.equal(summary.summary.capture_start, expectedCaptureStart);
|
||||
assert.equal(summary.summary.capture_end, expectedCaptureEnd);
|
||||
assert.equal(
|
||||
summary.summary.target.sha256,
|
||||
createHash("sha256")
|
||||
.update(await readFile(capturePath))
|
||||
.digest("hex"),
|
||||
);
|
||||
const cli = parseEvidence(
|
||||
JSON.parse(
|
||||
(
|
||||
await execute(
|
||||
process.execPath,
|
||||
[entrypoint, "inspect-pcap-capture", capturePath, "--json"],
|
||||
{ env: environment, timeout: 60000, maxBuffer: 16 * 1024 * 1024 },
|
||||
)
|
||||
).stdout,
|
||||
),
|
||||
);
|
||||
assert.equal(cli.normalized_result.capture_start, expectedCaptureStart);
|
||||
assert.equal(cli.normalized_result.capture_end, expectedCaptureEnd);
|
||||
const source = {
|
||||
kind: "retained-evidence",
|
||||
evidence_id: summary.parent_evidence_id,
|
||||
@@ -501,14 +463,10 @@ try {
|
||||
"network with spaces.pcap",
|
||||
"paged.pcap",
|
||||
]);
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources(
|
||||
[() => client.close(), () => transport.close(), () => root.close()],
|
||||
primaryError,
|
||||
);
|
||||
await client.close();
|
||||
await transport.close();
|
||||
await root.close();
|
||||
}
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
|
||||
+12
-43
@@ -8,9 +8,7 @@ import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { toolContract } from "../dist/contracts/toolContracts.js";
|
||||
import { hashStableFile } from "../dist/filesystem/StableFileHash.js";
|
||||
import { OwnedRegularFileCleanupFailure } from "../dist/filesystem/RegularFile.js";
|
||||
import { mcpTextValue } from "./lib/mcp-verifier-results.mjs";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
|
||||
const args = process.argv.slice(2);
|
||||
if (args.includes("--help") || args.includes("-h")) {
|
||||
@@ -36,23 +34,12 @@ Object.assign(environment, {
|
||||
const entrypoint = resolve("scripts/rea.mjs");
|
||||
const execute = promisify(execFile);
|
||||
const client = new Client({ name: "pcap-real-verifier", version: "1" });
|
||||
let primaryError;
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
env: environment,
|
||||
stderr: "pipe",
|
||||
});
|
||||
const hashOwners = new Map();
|
||||
const hashOwned = async (...args) => {
|
||||
try {
|
||||
return await hashStableFile(...args);
|
||||
} catch (cause) {
|
||||
if (cause instanceof OwnedRegularFileCleanupFailure)
|
||||
hashOwners.set(cause.owner, cause.path);
|
||||
throw cause;
|
||||
}
|
||||
};
|
||||
transport.stderr?.resume();
|
||||
try {
|
||||
await client.connect(transport);
|
||||
@@ -61,7 +48,7 @@ try {
|
||||
if (path === null)
|
||||
console.log("[unverified] Capture inspection: no --pcap was supplied");
|
||||
else {
|
||||
const identity = await hashOwned(path);
|
||||
const identity = await hashStableFile(path);
|
||||
const result = await run("inspect_pcap_capture", { path });
|
||||
assert.deepEqual(result.target, { path, ...identity });
|
||||
assert(result.packet_count >= 0);
|
||||
@@ -88,7 +75,7 @@ try {
|
||||
);
|
||||
assert.equal(result.coverage, partial ? "partial" : "complete");
|
||||
assert.deepEqual(
|
||||
await hashOwned(path),
|
||||
await hashStableFile(path),
|
||||
identity,
|
||||
"Input capture must remain unchanged",
|
||||
);
|
||||
@@ -96,36 +83,18 @@ try {
|
||||
`[ok] ${result.packet_count} packets; ${result.endpoint_count} addresses; coverage=${result.coverage}`,
|
||||
);
|
||||
}
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
const cleanup = [];
|
||||
for (const [owner, path] of hashOwners) {
|
||||
cleanup.push(async () => {
|
||||
try {
|
||||
await owner.close();
|
||||
hashOwners.delete(owner);
|
||||
} catch (cause) {
|
||||
throw new Error(`Could not close hash file handle for ${path}`, {
|
||||
cause,
|
||||
});
|
||||
}
|
||||
});
|
||||
try {
|
||||
await client.close();
|
||||
} finally {
|
||||
await transport.close();
|
||||
}
|
||||
cleanup.push(async () => {
|
||||
await closeVerifierResources([
|
||||
() => client.close(),
|
||||
() => transport.close(),
|
||||
]);
|
||||
assert.deepEqual(
|
||||
await readdir(root),
|
||||
[],
|
||||
`Owned capture resources remain under ${root}`,
|
||||
);
|
||||
await rmdir(root);
|
||||
});
|
||||
await closeVerifierResources(cleanup, primaryError);
|
||||
assert.deepEqual(
|
||||
await readdir(root),
|
||||
[],
|
||||
`Owned capture resources remain under ${root}`,
|
||||
);
|
||||
await rmdir(root);
|
||||
}
|
||||
console.log("All asserted pcap CLI/MCP checks passed");
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@ import { hasTypedSwitchEvidence } from "./verify-real-ghidra-switch-assertions.m
|
||||
import { access } from "node:fs/promises";
|
||||
|
||||
import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
|
||||
import { GHIDRA_SESSION_CAPABILITIES } from "../dist/ghidra/GhidraSessionValues.js";
|
||||
|
||||
export function assertLocalProcedureInfo(info, expectedAddress) {
|
||||
|
||||
@@ -12,7 +12,6 @@ import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import {
|
||||
inspectMipsReadelf,
|
||||
expectedMipsElfProfile,
|
||||
inspectLegacyMipsReadelf,
|
||||
assertMipsLoadedImage,
|
||||
assertMipsProbe,
|
||||
@@ -121,17 +120,6 @@ async function verifySoftFloat(call, symbols, byteOrder) {
|
||||
);
|
||||
return { storage: boundaries };
|
||||
}
|
||||
function assertIncompleteMipsInspection(error) {
|
||||
assert.equal(error.code, "capability_unavailable");
|
||||
assert.equal(error.details.selection_reason, "target_unsupported");
|
||||
const rejection = error.details.rejections.find(
|
||||
(candidate) => candidate.provider_id === "ghidra",
|
||||
);
|
||||
assert.equal(rejection?.code, "architecture_unsupported");
|
||||
assert.match(rejection.reason, /ABI declaration inspection is incomplete/u);
|
||||
assert.match(rejection.reason, /section header table/u);
|
||||
}
|
||||
|
||||
const reports = [];
|
||||
let primaryFailure;
|
||||
try {
|
||||
@@ -487,9 +475,28 @@ try {
|
||||
JSON.parse(await readFile(snapshotPath, "utf8")),
|
||||
);
|
||||
assert.equal(snapshot.target.architecture, "mips");
|
||||
const abi = independent.mips.abiFlags;
|
||||
assert.deepEqual(
|
||||
snapshot.binding.analysis_profile.parameters.mips_elf,
|
||||
expectedMipsElfProfile(independent.mips),
|
||||
{
|
||||
elf_class: independent.mips.elfClass,
|
||||
byte_order: independent.mips.byteOrder,
|
||||
type: independent.mips.type,
|
||||
flags: independent.mips.flags,
|
||||
abi_flags: {
|
||||
version: abi.version,
|
||||
isa_level: abi.isaLevel,
|
||||
isa_revision: abi.isaRevision,
|
||||
gpr_size: abi.gprSize,
|
||||
cpr1_size: abi.cpr1Size,
|
||||
cpr2_size: abi.cpr2Size,
|
||||
fp_abi: abi.fpAbi,
|
||||
isa_extension: abi.isaExtension,
|
||||
ases: abi.ases,
|
||||
flags1: abi.flags1,
|
||||
flags2: abi.flags2,
|
||||
},
|
||||
},
|
||||
"Snapshot profile did not retain the independently inspected ELF/ABI declaration",
|
||||
);
|
||||
assert.equal(
|
||||
@@ -610,8 +617,7 @@ try {
|
||||
// PSP keeps its independent Allegrex/A-B-A checks; carved PSP is not verified.
|
||||
let carved;
|
||||
if (!psp) {
|
||||
// A program-header ABI record survives carving, but GNU declarations in
|
||||
// uncaptured section headers remain unknown: both adapters must refuse.
|
||||
// Carved firmware keeps all program headers/load bytes but loses sections.
|
||||
const read16 = (offset) =>
|
||||
byteOrder === "little"
|
||||
? sourceBytes.readUInt16LE(offset)
|
||||
@@ -649,50 +655,79 @@ try {
|
||||
carvedResolved.value.mips.limitations.join(" "),
|
||||
/section header table/u,
|
||||
);
|
||||
const carvedError = requireMcpToolError(
|
||||
await client.callTool(
|
||||
{
|
||||
name: "open_binary",
|
||||
arguments: { path: carvedPath, provider_id: "ghidra" },
|
||||
},
|
||||
{ timeout: 60000 },
|
||||
const carvedTarget = await call("open_binary", {
|
||||
path: carvedPath,
|
||||
provider_id: "ghidra",
|
||||
});
|
||||
assert.equal(carvedTarget.sha256, carvedSha256);
|
||||
const carvedImage = await call("inspect_native_load_image");
|
||||
assertMipsLoadedImage(
|
||||
carvedImage.observations,
|
||||
byteOrder,
|
||||
carvedSha256,
|
||||
);
|
||||
const carvedProcedures = await call("list_procedures");
|
||||
assert.ok(
|
||||
carvedProcedures.some(
|
||||
(p) =>
|
||||
BigInt(p.address) === BigInt(independent.symbols.rea_mips_entry),
|
||||
),
|
||||
);
|
||||
assertIncompleteMipsInspection(carvedError);
|
||||
let carvedCliError;
|
||||
try {
|
||||
await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"function",
|
||||
carvedPath,
|
||||
independent.symbols.rea_mips_entry,
|
||||
"--provider",
|
||||
"ghidra",
|
||||
"--json",
|
||||
],
|
||||
{ env, timeout: 60000, maxBuffer: 1024 * 1024 },
|
||||
);
|
||||
} catch (cause) {
|
||||
carvedCliError = cause;
|
||||
}
|
||||
assert.ok(
|
||||
carvedCliError &&
|
||||
Number.isInteger(carvedCliError.code) &&
|
||||
carvedCliError.code !== 0,
|
||||
"Expected an incomplete-ABI refusal, not a timeout or success",
|
||||
const carvedDossier = functionDossierSchema.parse(
|
||||
await call("analyze_function", {
|
||||
procedure: independent.symbols.rea_mips_entry,
|
||||
}),
|
||||
);
|
||||
assert.ok(carvedDossier.pseudocode.trim().length > 0);
|
||||
const carvedSnapshotPath = join(
|
||||
workspace,
|
||||
`${byteOrder}-${floatAbi}-carved.snapshot.json`,
|
||||
);
|
||||
await call("close_binary", { snapshot_path: carvedSnapshotPath });
|
||||
const carvedSnapshot = parseAnalysisSnapshot(
|
||||
JSON.parse(await readFile(carvedSnapshotPath, "utf8")),
|
||||
);
|
||||
assert.equal(carvedSnapshot.target.sha256, carvedSha256);
|
||||
assert.ok(
|
||||
carvedSnapshot.evidence_bundle.records.some((record) =>
|
||||
parseEvidence(record).limitations.some((item) =>
|
||||
item.includes("section header table"),
|
||||
),
|
||||
),
|
||||
);
|
||||
const carvedCli = await execute(
|
||||
process.execPath,
|
||||
[
|
||||
entrypoint,
|
||||
"function",
|
||||
carvedPath,
|
||||
independent.symbols.rea_mips_entry,
|
||||
"--provider",
|
||||
"ghidra",
|
||||
"--json",
|
||||
],
|
||||
{ env, timeout: 240000, maxBuffer: 16 * 1024 * 1024 },
|
||||
);
|
||||
const carvedEvidence = parseEvidence(JSON.parse(carvedCli.stdout));
|
||||
assert.equal(carvedEvidence.subject?.digest.sha256, carvedSha256);
|
||||
assert.ok(
|
||||
carvedEvidence.limitations.some((item) =>
|
||||
item.includes("section header table"),
|
||||
),
|
||||
);
|
||||
assert.equal(
|
||||
functionDossierSchema.parse(carvedEvidence.normalized_result)
|
||||
.procedure.address,
|
||||
carvedDossier.procedure.address,
|
||||
);
|
||||
assertIncompleteMipsInspection(JSON.parse(carvedCliError.stdout));
|
||||
assert.deepEqual(await readFile(carvedPath), carvedBytes);
|
||||
carved = {
|
||||
sha256: carvedSha256,
|
||||
source_bytes: carvedBytes.length,
|
||||
section_header_offset: sectionOffset,
|
||||
status: "expected-incomplete-abi-refusal",
|
||||
effective_language: carvedImage.observations.language_id,
|
||||
limitations: carvedResolved.value.mips.limitations,
|
||||
cli_exit: carvedCliError.code,
|
||||
mcp_error: carvedError,
|
||||
procedures: carvedProcedures.length,
|
||||
};
|
||||
}
|
||||
reports.push({
|
||||
|
||||
@@ -11,7 +11,7 @@ import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import { parseConfig } from "../dist/config/parseConfig.js";
|
||||
import { GhidraClient } from "../dist/ghidra/GhidraClient.js";
|
||||
import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
|
||||
import { GhidraProvider } from "../dist/ghidra/GhidraProvider.js";
|
||||
import { silentLogger } from "../dist/logger.js";
|
||||
import { cleanupOwnedProcessGroup } from "../dist/process/ProcessOwnership.js";
|
||||
|
||||
@@ -19,7 +19,7 @@ import {
|
||||
parseGhidraInventoryResult,
|
||||
} from "../dist/ghidra/GhidraInventoryValues.js";
|
||||
import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
|
||||
import { GhidraHeadlessLauncher } from "../dist/ghidra/GhidraLauncher.js";
|
||||
import { GHIDRA_PROVIDER_IDENTITY } from "../dist/ghidra/GhidraProviderCapabilities.js";
|
||||
import {
|
||||
|
||||
@@ -11,7 +11,7 @@ import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
|
||||
import { resolveGhidraAnalysisProfile } from "../dist/ghidra/GhidraAnalysisProfile.js";
|
||||
import { GhidraClient } from "../dist/ghidra/GhidraClient.js";
|
||||
import { inspectGhidraInstallation } from "../dist/ghidra/GhidraInstallation.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraReleasePolicy.js";
|
||||
import { SUPPORTED_GHIDRA_VERSION } from "../dist/ghidra/GhidraInstallationPolicy.js";
|
||||
import { GhidraHeadlessLauncher } from "../dist/ghidra/GhidraLauncher.js";
|
||||
import { GHIDRA_PROVIDER_IDENTITY } from "../dist/ghidra/GhidraProviderCapabilities.js";
|
||||
|
||||
|
||||
@@ -83,11 +83,8 @@ const FIXTURE_SOURCE = String.raw`
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
static const char rea_kuna_utf8[] __attribute__((used)) = "＿φ( °-°)/ REA unicode marker";
|
||||
/* The leading NUL unit ends any UTF-16 run that bytes before this array would
|
||||
start: the UTF-8 marker's last byte and NUL decode as the unit 'r', so on
|
||||
layouts where it precedes this array Kuna reports "rREA wide marker". */
|
||||
static const unsigned short rea_kuna_wide[] __attribute__((used)) = {
|
||||
0,'R','E','A',' ','w','i','d','e',' ','m','a','r','k','e','r',0
|
||||
'R','E','A',' ','w','i','d','e',' ','m','a','r','k','e','r',0
|
||||
};
|
||||
#include <string.h>
|
||||
__attribute__((noinline)) unsigned rea_checksum(const unsigned char *p, size_t n) {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import { cp, mkdir, readFile, readdir } from "node:fs/promises";
|
||||
import { dirname, join, relative } from "node:path";
|
||||
|
||||
import { exec, execNpm, pathExists } from "./lib/verify-package-core.mjs";
|
||||
import { exec, pathExists } from "./lib/verify-package-core.mjs";
|
||||
|
||||
/** Exercise Skills' default root discovery without ignored build outputs. */
|
||||
export async function verifyRepositorySkill({ root, workspace }) {
|
||||
@@ -34,7 +34,8 @@ export async function verifyRepositorySkill({ root, workspace }) {
|
||||
await mkdir(consumer, { recursive: true });
|
||||
await mkdir(home, { recursive: true });
|
||||
const skillsVersion = "1.7.2";
|
||||
await execNpm(
|
||||
await exec(
|
||||
"npm",
|
||||
[
|
||||
"exec",
|
||||
"--yes",
|
||||
|
||||
@@ -12,7 +12,6 @@ import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { Ajv2020 } from "ajv/dist/2020.js";
|
||||
import { PrivateRuntimeRoot } from "../dist/process/PrivateRuntimeRoot.js";
|
||||
import { parseEvidence } from "../dist/domain/evidence.js";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
if (process.platform !== "linux")
|
||||
@@ -84,7 +83,6 @@ const expectedAddressSpace = Math.min(
|
||||
.map((value) => (value === "unlimited" ? Infinity : Number(value))),
|
||||
);
|
||||
|
||||
let primaryError;
|
||||
try {
|
||||
await writeFile(path, source);
|
||||
await client.connect(transport);
|
||||
@@ -385,14 +383,10 @@ try {
|
||||
"paged.vcd",
|
||||
"recording with spaces.vcd",
|
||||
]);
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources(
|
||||
[() => client.close(), () => transport.close(), () => root.close()],
|
||||
primaryError,
|
||||
);
|
||||
await client.close();
|
||||
await transport.close();
|
||||
await root.close();
|
||||
}
|
||||
console.log(
|
||||
JSON.stringify(
|
||||
|
||||
@@ -24,7 +24,6 @@ import {
|
||||
requireMcpToolError,
|
||||
} from "./lib/mcp-verifier-results.mjs";
|
||||
import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";
|
||||
import { WABT_OPERATION_TIMEOUT_MS } from "./lib/wabt-verifier-timeouts.mjs";
|
||||
|
||||
const directory = process.env.REA_WABT_BIN_DIRECTORY;
|
||||
if (!isAbsolute(directory ?? "")) {
|
||||
@@ -77,8 +76,6 @@ try {
|
||||
throw cause;
|
||||
}
|
||||
const client = new Client({ name: "wabt-artifact-verifier", version: "1" });
|
||||
const callTool = (request) =>
|
||||
client.callTool(request, { timeout: WABT_OPERATION_TIMEOUT_MS });
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [entrypoint, "mcp"],
|
||||
@@ -131,7 +128,7 @@ try {
|
||||
TMP: childTempRoot,
|
||||
TEMP: childTempRoot,
|
||||
},
|
||||
timeout: WABT_OPERATION_TIMEOUT_MS,
|
||||
timeout: 120_000,
|
||||
maxBuffer: 64 * 1024 * 1024,
|
||||
},
|
||||
)
|
||||
@@ -241,7 +238,7 @@ try {
|
||||
const cliValue = await inspectCli(input);
|
||||
assert.equal(cliValue.category, undefined, JSON.stringify(cliValue));
|
||||
const cli = parseEvidence(cliValue);
|
||||
const reply = await callTool({
|
||||
const reply = await client.callTool({
|
||||
name: "inspect_wasm_artifact",
|
||||
arguments: input,
|
||||
});
|
||||
@@ -335,7 +332,7 @@ try {
|
||||
},
|
||||
);
|
||||
}
|
||||
const bundleReply = await callTool({
|
||||
const bundleReply = await client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: {},
|
||||
});
|
||||
@@ -365,7 +362,7 @@ try {
|
||||
JSON.stringify(cliError),
|
||||
);
|
||||
const error = requireMcpToolError(
|
||||
await callTool({
|
||||
await client.callTool({
|
||||
name: "inspect_wasm_artifact",
|
||||
arguments: invalidInput,
|
||||
}),
|
||||
@@ -373,7 +370,7 @@ try {
|
||||
assert.equal(error.category, "invalid_input");
|
||||
const partial = error.details.partial_observation;
|
||||
assert.equal(partial.kind, "retained-evidence");
|
||||
const failedBundleReply = await callTool({
|
||||
const failedBundleReply = await client.callTool({
|
||||
name: "get_evidence_bundle",
|
||||
arguments: {},
|
||||
});
|
||||
|
||||
@@ -44,7 +44,6 @@ def markdown_ids(path):
|
||||
|
||||
def check_repository_links(root):
|
||||
"""Check local links in website Markdown and current-repository source links."""
|
||||
root = root.resolve()
|
||||
errors = []
|
||||
sources = {}
|
||||
for path in authored_markdown(root):
|
||||
@@ -319,7 +318,6 @@ def check_search_metadata(site, pages):
|
||||
|
||||
def check_site(site):
|
||||
"""Check assets, HTML fragment destinations and SVG syntax."""
|
||||
site = site.resolve()
|
||||
pages = {}
|
||||
errors = []
|
||||
references = 0
|
||||
|
||||
@@ -23,7 +23,6 @@ import { pathToFileURL } from "node:url";
|
||||
import { verifyWindowsProtocolInput } from "./lib/windows-protocol-input.mjs";
|
||||
import { verifyWindowsJobMemoryLimit } from "./lib/windows-job-memory-limit.mjs";
|
||||
import { verifyVolumeRootAppendLease } from "./lib/windows-volume-root-append-lease.mjs";
|
||||
import { closeVerifierResources } from "./lib/verifier-cleanup.mjs";
|
||||
|
||||
if (process.platform !== "win32")
|
||||
throw new Error(
|
||||
@@ -67,49 +66,6 @@ const exists = (path) =>
|
||||
() => true,
|
||||
() => false,
|
||||
);
|
||||
const startDeleteSharingDeniedReader = async (path) => {
|
||||
const child = spawn(
|
||||
"powershell.exe",
|
||||
[
|
||||
"-NoProfile",
|
||||
"-NonInteractive",
|
||||
"-Command",
|
||||
"$ErrorActionPreference = 'Stop'; " +
|
||||
"$stream = [IO.File]::Open($env:REA_CLEANUP_HELD_PATH, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::ReadWrite); " +
|
||||
"try { [Console]::WriteLine('ready'); [Console]::In.ReadLine() | Out-Null } " +
|
||||
"finally { $stream.Dispose() }",
|
||||
],
|
||||
{
|
||||
env: { ...process.env, REA_CLEANUP_HELD_PATH: path },
|
||||
stdio: ["pipe", "pipe", "pipe"],
|
||||
},
|
||||
);
|
||||
const closed = once(child, "close");
|
||||
void closed.catch(() => undefined);
|
||||
try {
|
||||
const [ready] = await once(child.stdout, "data", {
|
||||
signal: AbortSignal.timeout(15_000),
|
||||
});
|
||||
assert.equal(String(ready).trim(), "ready");
|
||||
} catch (cause) {
|
||||
try {
|
||||
child.kill();
|
||||
await closed;
|
||||
} catch (cleanupCause) {
|
||||
throw new AggregateError(
|
||||
[cause, cleanupCause],
|
||||
"Reader startup and child cleanup failed",
|
||||
{ cause },
|
||||
);
|
||||
}
|
||||
throw cause;
|
||||
}
|
||||
return { child, closed };
|
||||
};
|
||||
const stopDeleteSharingDeniedReader = async ({ child, closed }) => {
|
||||
child.kill();
|
||||
await closed;
|
||||
};
|
||||
const live = (pid) => {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
@@ -560,14 +516,32 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
|
||||
"cleanup-retry-",
|
||||
);
|
||||
const heldPath = join(retryRuntime.observation.path, "snapshot.bin");
|
||||
let holder;
|
||||
let primaryError;
|
||||
await retryRuntime.snapshot(source, "snapshot.bin");
|
||||
const holder = spawn(
|
||||
"powershell.exe",
|
||||
[
|
||||
"-NoProfile",
|
||||
"-NonInteractive",
|
||||
"-Command",
|
||||
"$ErrorActionPreference = 'Stop'; " +
|
||||
"$stream = [IO.File]::Open($env:REA_CLEANUP_HELD_PATH, [IO.FileMode]::Open, [IO.FileAccess]::Read, [IO.FileShare]::ReadWrite); " +
|
||||
"try { [Console]::WriteLine('ready'); [Console]::In.ReadLine() | Out-Null } " +
|
||||
"finally { $stream.Dispose() }",
|
||||
],
|
||||
{
|
||||
env: { ...process.env, REA_CLEANUP_HELD_PATH: heldPath },
|
||||
stdio: ["pipe", "pipe", "pipe"],
|
||||
},
|
||||
);
|
||||
const holderClosed = once(holder, "close");
|
||||
void holderClosed.catch(() => undefined);
|
||||
try {
|
||||
await retryRuntime.snapshot(source, "snapshot.bin");
|
||||
holder = await startDeleteSharingDeniedReader(heldPath);
|
||||
const [ready] = await once(holder.stdout, "data", {
|
||||
signal: AbortSignal.timeout(15_000),
|
||||
});
|
||||
assert.equal(String(ready).trim(), "ready");
|
||||
// The reader denies delete sharing. Cleanup must retain ownership when
|
||||
// its handle-relative open receives ERROR_SHARING_VIOLATION (32) through
|
||||
// the bounded automatic retries; a later explicit close must succeed.
|
||||
// its handle-relative open receives ERROR_SHARING_VIOLATION (32).
|
||||
await assert.rejects(retryRuntime.close(), { win32Code: 32 });
|
||||
assert.equal(
|
||||
windowsPrivateRuntime(retryRuntime.observation.path),
|
||||
@@ -578,8 +552,8 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
|
||||
() => retryRuntime.writeFile("after-close.txt", "forbidden"),
|
||||
/cleanup is pending/u,
|
||||
);
|
||||
holder.child.stdin.end("\n");
|
||||
const [exitCode] = await holder.closed;
|
||||
holder.stdin.end("\n");
|
||||
const [exitCode] = await holderClosed;
|
||||
assert.equal(exitCode, 0);
|
||||
await retryRuntime.close();
|
||||
await retryRuntime.close();
|
||||
@@ -589,73 +563,10 @@ process.stdout.write(JSON.stringify({executable:basename(process.execPath),abiVe
|
||||
/No native private runtime/u,
|
||||
);
|
||||
report.controls.cleanupFailureRetainsOwnershipForRetry = true;
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources(
|
||||
[
|
||||
...(holder === undefined
|
||||
? []
|
||||
: [() => stopDeleteSharingDeniedReader(holder)]),
|
||||
() => retryRuntime.close(),
|
||||
],
|
||||
primaryError,
|
||||
);
|
||||
}
|
||||
const transientRuntime = WindowsPrivateRuntime.create(
|
||||
workspace,
|
||||
"cleanup-transient-",
|
||||
);
|
||||
const transientHeldPath = join(
|
||||
transientRuntime.observation.path,
|
||||
"snapshot.bin",
|
||||
);
|
||||
let transientHolder;
|
||||
let transientPrimaryError;
|
||||
try {
|
||||
await transientRuntime.snapshot(source, "snapshot.bin");
|
||||
transientHolder = await startDeleteSharingDeniedReader(transientHeldPath);
|
||||
// Keep the reader held through the first close attempt. Without retries,
|
||||
// close rejects before the next event-loop turn; with retries, it remains
|
||||
// pending until the caller releases this sharing conflict.
|
||||
let closeSettled = false;
|
||||
const closing = transientRuntime.close();
|
||||
void closing.then(
|
||||
() => {
|
||||
closeSettled = true;
|
||||
},
|
||||
() => {
|
||||
closeSettled = true;
|
||||
},
|
||||
);
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
assert.equal(closeSettled, false);
|
||||
transientHolder.child.stdin.end("\n");
|
||||
const [, [exitCode]] = await Promise.all([
|
||||
closing,
|
||||
transientHolder.closed,
|
||||
]);
|
||||
assert.equal(exitCode, 0);
|
||||
assert.equal(await exists(transientRuntime.observation.path), false);
|
||||
assert.throws(
|
||||
() => windowsPrivateRuntime(transientRuntime.observation.path),
|
||||
/No native private runtime/u,
|
||||
);
|
||||
report.controls.cleanupTransientConflictRetries = true;
|
||||
} catch (cause) {
|
||||
transientPrimaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources(
|
||||
[
|
||||
...(transientHolder === undefined
|
||||
? []
|
||||
: [() => stopDeleteSharingDeniedReader(transientHolder)]),
|
||||
() => transientRuntime.close(),
|
||||
],
|
||||
transientPrimaryError,
|
||||
);
|
||||
holder.kill();
|
||||
await holderClosed.catch(() => undefined);
|
||||
await retryRuntime.close();
|
||||
}
|
||||
report.controls = {
|
||||
...report.controls,
|
||||
|
||||
@@ -14,15 +14,11 @@ import { join } from "node:path";
|
||||
import { parse as parseJsonc } from "jsonc-parser";
|
||||
import { supportedClients } from "../dist/application/SupportedClients.js";
|
||||
import { promisify } from "node:util";
|
||||
import { GHIDRA_BRIDGE_SOURCES } from "../src/ghidra/GhidraBridgeSources.ts";
|
||||
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
|
||||
import {
|
||||
execNpm,
|
||||
verifyCompleteToolCatalog,
|
||||
} from "./lib/verify-package-core.mjs";
|
||||
import { verifyCompleteToolCatalog } from "./lib/verify-package-core.mjs";
|
||||
import { verifyPackageUpdate } from "./verify-package-update.mjs";
|
||||
import { completeVerifierRun, createVerifierRun } from "./lib/verifier-run.mjs";
|
||||
|
||||
@@ -36,9 +32,9 @@ let report;
|
||||
try {
|
||||
const packed = JSON.parse(
|
||||
(
|
||||
await execNpm(
|
||||
await npm(
|
||||
["pack", "--json", "--silent", "--pack-destination", workspace],
|
||||
{ cwd: root, windowsHide: true },
|
||||
root,
|
||||
)
|
||||
).stdout,
|
||||
);
|
||||
@@ -53,9 +49,7 @@ try {
|
||||
);
|
||||
const packagedPaths = new Set(packageResult.files.map(({ path }) => path));
|
||||
for (const required of [
|
||||
...Object.values(GHIDRA_BRIDGE_SOURCES).map(
|
||||
(name) => `bridge/ghidra/${name}`,
|
||||
),
|
||||
"bridge/ghidra/ReaGhidraBridge.java",
|
||||
"native/windows/build/manifest.json",
|
||||
"native/windows/build/rea-windows-x64.node",
|
||||
"dist/android/JadxWorkspaceRoot.js",
|
||||
@@ -69,9 +63,9 @@ try {
|
||||
|
||||
const tarball = join(workspace, packageResult.filename);
|
||||
await access(tarball);
|
||||
await execNpm(
|
||||
await npm(
|
||||
["install", "--no-package-lock", "--no-save", "--prefix", prefix, tarball],
|
||||
{ cwd: workspace, windowsHide: true },
|
||||
workspace,
|
||||
);
|
||||
const entry = join(
|
||||
prefix,
|
||||
@@ -215,9 +209,9 @@ try {
|
||||
throw new Error(`Packaged uninstall did not remove ${id}`);
|
||||
|
||||
if (process.platform !== "win32")
|
||||
await execNpm(
|
||||
await npm(
|
||||
["install", "--global", "--ignore-scripts", "--prefix", prefix, tarball],
|
||||
{ cwd: workspace, windowsHide: true },
|
||||
workspace,
|
||||
);
|
||||
const update = await verifyPackageUpdate({
|
||||
prefix,
|
||||
@@ -247,3 +241,16 @@ try {
|
||||
process.stdout.write(
|
||||
`${JSON.stringify({ verifier_run: await completeVerifierRun(verifierRun), ...report })}\n`,
|
||||
);
|
||||
|
||||
function npm(arguments_, cwd) {
|
||||
const npmExecPath = process.env.npm_execpath;
|
||||
return npmExecPath === undefined
|
||||
? exec(process.platform === "win32" ? "npm.cmd" : "npm", arguments_, {
|
||||
cwd,
|
||||
windowsHide: true,
|
||||
})
|
||||
: exec(process.execPath, [npmExecPath, ...arguments_], {
|
||||
cwd,
|
||||
windowsHide: true,
|
||||
});
|
||||
}
|
||||
@@ -1,482 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
import assert from "node:assert/strict";
|
||||
import { createHash, randomUUID } from "node:crypto";
|
||||
import { createReadStream } from "node:fs";
|
||||
import { readFile, writeFile } from "node:fs/promises";
|
||||
import { isAbsolute, join } from "node:path";
|
||||
import { performance } from "node:perf_hooks";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import { parseArgs } from "node:util";
|
||||
import { Client } from "@modelcontextprotocol/client";
|
||||
import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
|
||||
import { createEvidence } from "../../../dist/domain/evidence.js";
|
||||
import { PrivateRuntimeRoot } from "../../../dist/process/PrivateRuntimeRoot.js";
|
||||
import {
|
||||
OwnedCommandFailure,
|
||||
runOwnedCommand,
|
||||
} from "../../../dist/process/OwnedCommand.js";
|
||||
import { closeVerifierResources } from "../../lib/verifier-cleanup.mjs";
|
||||
import {
|
||||
matchesStructuredScopeExpectation,
|
||||
structuredScopeExpectationsSchema,
|
||||
} from "../../lib/javascript-file-scope-oracle.mjs";
|
||||
|
||||
const { values } = parseArgs({
|
||||
options: {
|
||||
artifact: { type: "string" },
|
||||
"addon-path": { type: "string" },
|
||||
"native-sha256": { type: "string" },
|
||||
"source-path": { type: "string", multiple: true },
|
||||
"structured-path": { type: "string", multiple: true },
|
||||
"structured-expectations": { type: "string" },
|
||||
"validate-structured-from-export": { type: "boolean", default: false },
|
||||
"analysis-timeout-ms": { type: "string" },
|
||||
"expect-timeout": { type: "boolean", default: false },
|
||||
rounds: { type: "string", default: "3" },
|
||||
"cli-parity": { type: "boolean", default: false },
|
||||
"tokenizer-python": { type: "string" },
|
||||
"require-safe": { type: "boolean", default: false },
|
||||
},
|
||||
strict: true,
|
||||
});
|
||||
assert.ok(
|
||||
values.artifact && isAbsolute(values.artifact),
|
||||
"--artifact must be absolute",
|
||||
);
|
||||
assert.ok(
|
||||
values["addon-path"] &&
|
||||
!isAbsolute(values["addon-path"]) &&
|
||||
values["addon-path"]
|
||||
.split("/")
|
||||
.every((part) => part !== "" && part !== "." && part !== ".."),
|
||||
"--addon-path must be a normalized archive-relative path",
|
||||
);
|
||||
assert.match(
|
||||
values["native-sha256"] ?? "",
|
||||
/^[a-f0-9]{64}$/,
|
||||
"--native-sha256 pins prior native bytes; it does not prove availability",
|
||||
);
|
||||
const rounds = Number(values.rounds);
|
||||
assert.ok(Number.isSafeInteger(rounds) && rounds > 0);
|
||||
const analysisTimeoutMs =
|
||||
values["analysis-timeout-ms"] === undefined
|
||||
? undefined
|
||||
: Number(values["analysis-timeout-ms"]);
|
||||
assert.ok(
|
||||
analysisTimeoutMs === undefined ||
|
||||
(Number.isSafeInteger(analysisTimeoutMs) && analysisTimeoutMs > 0),
|
||||
);
|
||||
assert.ok(!values["expect-timeout"] || analysisTimeoutMs !== undefined);
|
||||
assert.ok(!values["validate-structured-from-export"] || values["cli-parity"]);
|
||||
const structuredExpectations = structuredScopeExpectationsSchema.parse(
|
||||
JSON.parse(values["structured-expectations"] ?? "{}"),
|
||||
);
|
||||
for (const path of Object.keys(structuredExpectations))
|
||||
assert.ok(
|
||||
values["structured-path"]?.includes(path),
|
||||
`Expected structured path was not selected for verification: ${path}`,
|
||||
);
|
||||
if (values["expect-timeout"])
|
||||
for (const path of values["structured-path"] ?? [])
|
||||
assert.ok(
|
||||
Object.hasOwn(structuredExpectations, path),
|
||||
`--structured-expectations must name the expected operation/status for ${path}`,
|
||||
);
|
||||
const environment = {
|
||||
PATH: process.env.PATH ?? "/usr/bin:/bin",
|
||||
REA_LOG_LEVEL: "silent",
|
||||
REA_ANALYSIS_PROVIDER: "auto",
|
||||
HOPPER_LAUNCHER_PATH: "/rea-unconfigured-deep-provider/hopper",
|
||||
};
|
||||
const transport = new StdioClientTransport({
|
||||
command: process.execPath,
|
||||
args: [fileURLToPath(new URL("../../rea.mjs", import.meta.url)), "mcp"],
|
||||
env: environment,
|
||||
stderr: "pipe",
|
||||
});
|
||||
const client = new Client({
|
||||
name: "javascript-native-handoff-verifier",
|
||||
version: "1",
|
||||
});
|
||||
const serialize = (value) => JSON.stringify(value);
|
||||
const digest = (value) =>
|
||||
createHash("sha256").update(serialize(value)).digest("hex");
|
||||
const fileDigest = async (path) => {
|
||||
const hash = createHash("sha256");
|
||||
for await (const chunk of createReadStream(path)) hash.update(chunk);
|
||||
return hash.digest("hex");
|
||||
};
|
||||
const simulatedNativeEvidence = (path, sha256) =>
|
||||
createEvidence(
|
||||
{ path, sha256, format: "raw-binary" },
|
||||
{ id: "ghidra", name: "Ghidra", version: "simulated" },
|
||||
{
|
||||
operation: "binary_overview",
|
||||
parameters: {},
|
||||
result: {
|
||||
summary:
|
||||
"Simulated subject-linkage input; no native provider executed.",
|
||||
},
|
||||
limitations: ["No native provider behavior is established."],
|
||||
},
|
||||
);
|
||||
let temporary;
|
||||
let primaryError;
|
||||
let retainTemporary = false;
|
||||
let report;
|
||||
const ownedCommand = async (command, arguments_, timeoutMs = 60_000) => {
|
||||
try {
|
||||
return await runOwnedCommand(
|
||||
{
|
||||
command,
|
||||
arguments: arguments_,
|
||||
cwd: temporary.path,
|
||||
env: environment,
|
||||
runId: `rea-native-handoff-${randomUUID()}`,
|
||||
expectedCommand: command === process.execPath ? process.execPath : null,
|
||||
sweepTokenOwnedProcesses: true,
|
||||
},
|
||||
{ timeoutMs, diagnosticBytes: 16 * 1024 * 1024 },
|
||||
);
|
||||
} catch (cause) {
|
||||
retainTemporary ||=
|
||||
cause instanceof OwnedCommandFailure && cause.cleanupOwner !== undefined;
|
||||
throw cause;
|
||||
}
|
||||
};
|
||||
try {
|
||||
const archiveSha256 = await fileDigest(values.artifact);
|
||||
const companion = join(`${values.artifact}.unpacked`, values["addon-path"]);
|
||||
let companionSha256 = null;
|
||||
try {
|
||||
companionSha256 = await fileDigest(companion);
|
||||
} catch (cause) {
|
||||
if (cause?.code !== "ENOENT") throw cause;
|
||||
}
|
||||
if (companionSha256 !== null)
|
||||
assert.equal(companionSha256, values["native-sha256"]);
|
||||
const native = simulatedNativeEvidence(companion, values["native-sha256"]);
|
||||
const container = simulatedNativeEvidence(values.artifact, archiveSha256);
|
||||
await client.connect(transport);
|
||||
transport.stderr?.on("data", () => undefined);
|
||||
const tools = (await client.listTools()).tools;
|
||||
const catalog = tools.map(({ name, description, inputSchema }) => ({
|
||||
name,
|
||||
description,
|
||||
inputSchema,
|
||||
}));
|
||||
const selected = catalog.filter(({ name }) =>
|
||||
["analyze_javascript_application", "trace_application_feature"].includes(
|
||||
name,
|
||||
),
|
||||
);
|
||||
assert.equal(selected.length, 2);
|
||||
const call = async (name, arguments_, allowTimeout = false) => {
|
||||
const response = await client.callTool(
|
||||
{ name, arguments: arguments_ },
|
||||
{ timeout: 360_000 },
|
||||
);
|
||||
let projection = response.structuredContent;
|
||||
if (response.isError === true) {
|
||||
assert.ok(
|
||||
allowTimeout,
|
||||
serialize({ name, arguments: arguments_, response }),
|
||||
);
|
||||
const text = response.content.find(({ type }) => type === "text");
|
||||
assert.ok(text?.type === "text");
|
||||
projection = JSON.parse(text.text);
|
||||
assert.equal(projection.error.code, "provider_timeout");
|
||||
assert.equal(
|
||||
projection.error.details.partial_observation.kind,
|
||||
"retained-evidence",
|
||||
);
|
||||
} else assert.ok(projection?.evidence_id);
|
||||
return {
|
||||
request: { name, arguments: arguments_ },
|
||||
response: projection,
|
||||
wire_response: response,
|
||||
};
|
||||
};
|
||||
const prepStart = performance.now();
|
||||
const preparation = await call(
|
||||
"analyze_javascript_application",
|
||||
{
|
||||
input_path: values.artifact,
|
||||
detail: "summary",
|
||||
...(analysisTimeoutMs === undefined
|
||||
? {}
|
||||
: { analysis_timeout_ms: analysisTimeoutMs }),
|
||||
...(values["source-path"] === undefined
|
||||
? {}
|
||||
: { source_paths: values["source-path"] }),
|
||||
},
|
||||
values["expect-timeout"],
|
||||
);
|
||||
const preparationMs = performance.now() - prepStart;
|
||||
const timedOut = preparation.wire_response.isError === true;
|
||||
assert.equal(timedOut, values["expect-timeout"]);
|
||||
if (!timedOut)
|
||||
assert.equal(preparation.response.subject.digest.sha256, archiveSha256);
|
||||
const sourceId = timedOut
|
||||
? preparation.response.error.details.partial_observation.evidence_id
|
||||
: preparation.response.normalized_result.parent_evidence_id;
|
||||
assert.match(sourceId, /^ev_[a-f0-9]{64}$/);
|
||||
const query = {
|
||||
application: { kind: "retained-evidence", evidence_id: sourceId },
|
||||
native_observations: [container, native],
|
||||
seed: {
|
||||
kind: "string",
|
||||
value: values["addon-path"],
|
||||
match: "exact",
|
||||
case_sensitive: true,
|
||||
},
|
||||
direction: "outgoing",
|
||||
};
|
||||
const samples = [];
|
||||
let first;
|
||||
for (let round = 0; round < rounds; round++) {
|
||||
const start = performance.now();
|
||||
const result = await call("trace_application_feature", query);
|
||||
const elapsedMs = performance.now() - start;
|
||||
if (first === undefined) first = result;
|
||||
else assert.equal(result.response.evidence_id, first.response.evidence_id);
|
||||
samples.push({
|
||||
round,
|
||||
elapsed_ms: elapsedMs,
|
||||
structured_reply_bytes: Buffer.byteLength(serialize(result.response)),
|
||||
full_tool_reply_bytes: Buffer.byteLength(serialize(result.wire_response)),
|
||||
});
|
||||
}
|
||||
const trace = first.response.normalized_result;
|
||||
const addons = trace.graph.nodes.filter(
|
||||
({ kind }) => kind === "native-addon",
|
||||
);
|
||||
assert.equal(
|
||||
addons.length,
|
||||
1,
|
||||
"The selected native add-on must remain visible",
|
||||
);
|
||||
const addon = addons[0];
|
||||
const unavailable = addon.observations.some(
|
||||
({ properties }) => properties.availability === "unavailable",
|
||||
);
|
||||
const expectedLinks = [
|
||||
sourceId,
|
||||
...(companionSha256 === null ? [] : [native.evidence_id]),
|
||||
].sort();
|
||||
const safeIdentity =
|
||||
serialize(trace.evidence_links) === serialize(expectedLinks) &&
|
||||
(companionSha256 === null
|
||||
? unavailable &&
|
||||
addon.identity.strategy !== "content-digest" &&
|
||||
trace.coverage.status === "partial" &&
|
||||
trace.native_handoffs.length === 0
|
||||
: addon.identity.strategy === "content-digest" &&
|
||||
addon.identity.sha256 === companionSha256 &&
|
||||
trace.native_handoffs.length === 1 &&
|
||||
trace.native_handoffs[0].artifact_sha256 === companionSha256 &&
|
||||
trace.native_handoffs[0].status === "evidence-linked" &&
|
||||
serialize(trace.native_handoffs[0].evidence_ids) ===
|
||||
serialize([native.evidence_id]));
|
||||
const analysisScopes = (result, path) =>
|
||||
result.graph.nodes.flatMap((node) =>
|
||||
node.kind !== "unknown"
|
||||
? []
|
||||
: node.observations.flatMap((observation) =>
|
||||
observation.properties.path === path &&
|
||||
observation.properties.analysis_failure !== undefined
|
||||
? [{ node_id: node.node_id, ...observation }]
|
||||
: [],
|
||||
),
|
||||
);
|
||||
const nativeScopes = analysisScopes(trace, values["addon-path"]);
|
||||
const structuredQueries = [];
|
||||
const structuredScopes = [];
|
||||
for (const path of values["validate-structured-from-export"]
|
||||
? []
|
||||
: (values["structured-path"] ?? [])) {
|
||||
const result = await call("trace_application_feature", {
|
||||
...query,
|
||||
native_observations: [],
|
||||
seed: { ...query.seed, value: path },
|
||||
});
|
||||
structuredQueries.push(result);
|
||||
structuredScopes.push({
|
||||
source: "retained-feature-trace",
|
||||
path,
|
||||
scopes: analysisScopes(result.response.normalized_result, path),
|
||||
evidence_id: result.response.evidence_id,
|
||||
source_coverage: result.response.normalized_result.coverage,
|
||||
graph_coverage: result.response.normalized_result.graph.coverage,
|
||||
});
|
||||
}
|
||||
let cliParity = null;
|
||||
if (values["cli-parity"]) {
|
||||
temporary = await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-native-handoff-verifier-",
|
||||
});
|
||||
const bundlePath = join(temporary.path, "bundle.json");
|
||||
const exported = await client.callTool({
|
||||
name: "export_evidence_bundle",
|
||||
arguments: { path: bundlePath },
|
||||
});
|
||||
assert.notEqual(exported.isError, true, serialize(exported));
|
||||
const bundle = JSON.parse(await readFile(bundlePath, "utf8"));
|
||||
const parent = bundle.records.find(
|
||||
({ evidence_id }) => evidence_id === sourceId,
|
||||
);
|
||||
assert.ok(parent, "Export omitted the retained parent");
|
||||
assert.equal(parent.normalized_result.root_artifact_sha256, archiveSha256);
|
||||
if (values["validate-structured-from-export"])
|
||||
for (const path of values["structured-path"] ?? []) {
|
||||
const retained = parent.normalized_result;
|
||||
const matchingNodes = retained.graph.nodes.filter((node) =>
|
||||
node.observations.some(({ properties }) => properties.path === path),
|
||||
);
|
||||
assert.ok(matchingNodes.length > 0, `Missing retained path: ${path}`);
|
||||
// Diagnostic validation of the complete backend record is distinct
|
||||
// from the inline native analyst task used by this control's tokens.
|
||||
structuredScopes.push({
|
||||
source: "exported-parent-validation",
|
||||
path,
|
||||
scopes: analysisScopes(retained, path),
|
||||
source_evidence_id: parent.evidence_id,
|
||||
retained_matching_nodes: matchingNodes.length,
|
||||
graph_coverage: retained.graph.coverage,
|
||||
});
|
||||
}
|
||||
const request = join(temporary.path, "trace.json");
|
||||
// The CLI's portable file contract takes complete Evidence; MCP resolves a
|
||||
// same-session reference into the same shared application workflow.
|
||||
await writeFile(request, serialize({ ...query, application: parent }));
|
||||
const result = await ownedCommand(
|
||||
process.execPath,
|
||||
[
|
||||
fileURLToPath(new URL("../../rea.mjs", import.meta.url)),
|
||||
"trace-application-feature",
|
||||
request,
|
||||
"--json",
|
||||
],
|
||||
120_000,
|
||||
);
|
||||
const evidence = JSON.parse(result.stdout.text);
|
||||
assert.deepEqual(evidence.normalized_result, trace);
|
||||
assert.equal(evidence.evidence_id, first.response.evidence_id);
|
||||
cliParity = {
|
||||
exact_cli_mcp_trace_parity: true,
|
||||
evidence_id: evidence.evidence_id,
|
||||
};
|
||||
}
|
||||
const safeApplicability =
|
||||
nativeScopes.length === 0 &&
|
||||
structuredScopes.every(({ path, scopes }) =>
|
||||
timedOut
|
||||
? matchesStructuredScopeExpectation(
|
||||
scopes,
|
||||
structuredExpectations[path],
|
||||
)
|
||||
: scopes.length === 0,
|
||||
);
|
||||
let tokenCosts = null;
|
||||
if (values["tokenizer-python"]) {
|
||||
temporary ??= await PrivateRuntimeRoot.create({
|
||||
prefix: "rea-native-handoff-verifier-",
|
||||
});
|
||||
const input = join(temporary.path, "token-input.json");
|
||||
await writeFile(
|
||||
input,
|
||||
serialize({
|
||||
catalog,
|
||||
selected,
|
||||
preparation,
|
||||
queries: [first, ...structuredQueries],
|
||||
}),
|
||||
);
|
||||
const result = await ownedCommand(values["tokenizer-python"], [
|
||||
"-c",
|
||||
`import json,sys,tiktoken
|
||||
with open(sys.argv[1],encoding='utf-8') as f:d=json.load(f)
|
||||
enc=tiktoken.get_encoding('cl100k_base')
|
||||
def n(v):return len(enc.encode(json.dumps(v,ensure_ascii=False,separators=(',',':')),disallowed_special=()))
|
||||
requests=n(d['preparation']['request'])+sum(n(q['request']) for q in d['queries'])
|
||||
structured=n(d['preparation']['response'])+sum(n(q['response']) for q in d['queries'])
|
||||
full_reply=n(d['preparation']['wire_response'])+sum(n(q['wire_response']) for q in d['queries'])
|
||||
s=n(d['selected']);a=n(d['catalog'])
|
||||
print(json.dumps(dict(tokenizer='cl100k_base',tiktoken_version=tiktoken.__version__,selected_catalog=s,full_catalog=a,requests=requests,structured_replies=structured,full_tool_replies=full_reply,selected_catalog_structured_task=s+requests+structured,full_catalog_structured_task=a+requests+structured,selected_catalog_full_reply_task=s+requests+full_reply,full_catalog_full_reply_task=a+requests+full_reply)))`,
|
||||
input,
|
||||
]);
|
||||
tokenCosts = JSON.parse(result.stdout.text);
|
||||
}
|
||||
report = {
|
||||
scope:
|
||||
"Real shipped-ASAR native identity through public CLI/stdio MCP; simulated native Evidence only, no provider/application executed",
|
||||
artifact: { path: values.artifact, sha256: archiveSha256 },
|
||||
addon_path: values["addon-path"],
|
||||
companion_sha256_observed: companionSha256,
|
||||
prior_native_sha256_supplied: values["native-sha256"],
|
||||
source_paths: values["source-path"] ?? null,
|
||||
preparation_outcome: timedOut ? "provider_timeout" : "completed",
|
||||
analysis_timeout_ms: analysisTimeoutMs ?? null,
|
||||
parent_evidence_id: sourceId,
|
||||
trace_evidence_id: first.response.evidence_id,
|
||||
trace_subject: first.response.subject,
|
||||
preparation_ms: preparationMs,
|
||||
samples,
|
||||
safe_identity: safeIdentity,
|
||||
safe_applicability: safeApplicability,
|
||||
native_analysis_scopes: nativeScopes,
|
||||
structured_scopes: structuredScopes,
|
||||
structured_expectations: structuredExpectations,
|
||||
modeled_structured_trace_count: structuredQueries.length,
|
||||
node: {
|
||||
node_id: addon.node_id,
|
||||
identity: addon.identity,
|
||||
unavailable_observed: unavailable,
|
||||
basis: addon.observations.map(({ evidence }) => ({
|
||||
authority: evidence.authority,
|
||||
state: evidence.state,
|
||||
confidence: evidence.confidence,
|
||||
artifact: evidence.artifact,
|
||||
location: evidence.location,
|
||||
})),
|
||||
},
|
||||
native_handoffs: trace.native_handoffs,
|
||||
evidence_links: trace.evidence_links,
|
||||
source_coverage: trace.coverage,
|
||||
graph_coverage: trace.graph.coverage,
|
||||
facts_sha256: digest({
|
||||
node: addon,
|
||||
native_handoffs: trace.native_handoffs,
|
||||
evidence_links: trace.evidence_links,
|
||||
coverage: trace.coverage,
|
||||
}),
|
||||
cli_parity: cliParity,
|
||||
token_costs: tokenCosts,
|
||||
conditions:
|
||||
"Fresh MCP session, selected analysis followed by retained traces. Task token counts include one analysis summary or parsed timeout error, one native trace and each requested structured-path trace, with name/description/inputSchema catalog projections. Structured Evidence/parsed error and complete-tool-reply projections are alternatives, not billing. Repeated native rounds, export, CLI parity and tokenizer are validation overhead outside task tokens but inside total resource receipts. Filesystem/build caches uncontrolled. Incorrect identity/applicability is not a successful equivalent task or efficiency credit.",
|
||||
};
|
||||
if (values["require-safe"]) {
|
||||
assert.ok(safeIdentity, "Native identity/linkage oracle failed");
|
||||
assert.ok(safeApplicability, "File analysis applicability oracle failed");
|
||||
}
|
||||
} catch (cause) {
|
||||
primaryError = cause;
|
||||
throw cause;
|
||||
} finally {
|
||||
await closeVerifierResources(
|
||||
[
|
||||
() => client.close(),
|
||||
() => transport.close(),
|
||||
async () => {
|
||||
if (retainTemporary)
|
||||
throw new Error(
|
||||
`Command cleanup incomplete; retaining owned inputs at ${temporary?.path}.`,
|
||||
);
|
||||
await temporary?.close();
|
||||
},
|
||||
],
|
||||
primaryError,
|
||||
);
|
||||
}
|
||||
console.log(serialize(report));
|
||||
@@ -880,42 +880,6 @@ exit 1`,
|
||||
});
|
||||
});
|
||||
|
||||
it("binds a push digest to the bytes adb consumes after caller-path replacement", async () => {
|
||||
const { binary, root } = await writeAdbStub(
|
||||
(stubRoot) => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fi
|
||||
if [ "$1" = "-s" ] && [ "$4" = "test" ]; then exit 1; fi
|
||||
if [ "$1" = "-s" ] && [ "$3" = "push" ]; then
|
||||
printf 'replacement-payload' > "${stubRoot}/payload.bin"
|
||||
cat "$4" > "${stubRoot}/consumed.bin" || exit 1
|
||||
exit 0
|
||||
fi
|
||||
if [ "$1" = "-s" ] && [ "$4" = "sha256sum" ]; then exit 1; fi
|
||||
exit 1`,
|
||||
);
|
||||
const localFile = join(root, "payload.bin");
|
||||
await writeFile(localFile, "original-payload");
|
||||
const result = await evidenceResult(providerOver(binary), {
|
||||
operation: "push_adb_file",
|
||||
input: {
|
||||
serial: "emulator-5554",
|
||||
local_path: localFile,
|
||||
device_path: "/data/local/tmp/payload.bin",
|
||||
overwrite: false,
|
||||
},
|
||||
});
|
||||
const consumedDigest = createHash("sha256")
|
||||
.update(await readFile(join(root, "consumed.bin")))
|
||||
.digest("hex");
|
||||
expect(result).toMatchObject({
|
||||
local_path: localFile,
|
||||
sha256: consumedDigest,
|
||||
});
|
||||
expect(await readFile(localFile, "utf8")).toBe("replacement-payload");
|
||||
expect(await readFile(join(root, "consumed.bin"), "utf8")).toBe(
|
||||
"original-payload",
|
||||
);
|
||||
});
|
||||
|
||||
it("reports a digest mismatch after push as a changed artifact", async () => {
|
||||
const { binary, root } = await writeAdbStub(
|
||||
() => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fi
|
||||
@@ -1315,33 +1279,6 @@ exit 1`,
|
||||
expect(projected.message).toContain("INSTALL_FAILED_ALREADY_EXISTS");
|
||||
});
|
||||
|
||||
it("binds an install digest to the bytes adb consumes after caller-path replacement", async () => {
|
||||
const { binary, root } = await writeAdbStub(
|
||||
(stubRoot) => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fi
|
||||
if [ "$1" = "-s" ] && [ "$3" = "install" ]; then
|
||||
printf 'replacement-apk' > "${stubRoot}/app.apk"
|
||||
cat "$4" > "${stubRoot}/consumed.bin" || exit 1
|
||||
printf 'Success\\n'
|
||||
exit 0
|
||||
fi
|
||||
exit 1`,
|
||||
);
|
||||
const apk = join(root, "app.apk");
|
||||
await writeFile(apk, "original-apk");
|
||||
const result = await evidenceResult(providerOver(binary), {
|
||||
operation: "install_adb_package",
|
||||
input: { serial: "emulator-5554", apk_path: apk, replace: false },
|
||||
});
|
||||
const consumedDigest = createHash("sha256")
|
||||
.update(await readFile(join(root, "consumed.bin")))
|
||||
.digest("hex");
|
||||
expect(result).toMatchObject({ apk_path: apk, sha256: consumedDigest });
|
||||
expect(await readFile(apk, "utf8")).toBe("replacement-apk");
|
||||
expect(await readFile(join(root, "consumed.bin"), "utf8")).toBe(
|
||||
"original-apk",
|
||||
);
|
||||
});
|
||||
|
||||
it("uninstalls a package and reports the device's refusal for absent ones", async () => {
|
||||
const { binary } = await writeAdbStub(
|
||||
() => `if [ "$1" = "version" ]; then ${VERSION_BLOCK}; exit 0; fi
|
||||
|
||||
+269
-568
File diff suppressed because it is too large.
Load diff
+32
-93
@@ -14,7 +14,6 @@ import {
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import { ProviderAdapterError } from "../domain/providerAdapterError.js";
|
||||
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
|
||||
import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
|
||||
import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
|
||||
import type { AndroidRequest } from "../domain/android/androidAnalysis.js";
|
||||
import type { BinaryTarget } from "../domain/binaryTargetTypes.js";
|
||||
@@ -27,15 +26,8 @@ import {
|
||||
snapshotAndroidEngine,
|
||||
snapshotAndroidTarget,
|
||||
} from "./AndroidTargetSnapshot.js";
|
||||
import {
|
||||
hashStableFile,
|
||||
StableFileHashCleanupFailure,
|
||||
} from "../filesystem/StableFileHash.js";
|
||||
import {
|
||||
OwnedRegularFileCleanupFailure,
|
||||
RegularFileChangedError,
|
||||
} from "../filesystem/RegularFile.js";
|
||||
import type { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
|
||||
import { hashStableFile } from "../filesystem/StableFileHash.js";
|
||||
import { RegularFileChangedError } from "../filesystem/RegularFile.js";
|
||||
import {
|
||||
inspectJadxAvailability,
|
||||
resolveJadxConfigurationInputs,
|
||||
@@ -74,38 +66,8 @@ const executionError = (context: {
|
||||
session: JadxSession | undefined;
|
||||
}): AnalysisError => {
|
||||
const { cause, request, timeout, signal, session } = context;
|
||||
if (cause instanceof OwnedRegularFileCleanupFailure) {
|
||||
const primary =
|
||||
signal?.aborted === true
|
||||
? new AnalysisCancelledError(request.operation, { cause: cause.cause })
|
||||
: timeout.aborted
|
||||
? new AnalysisTimeoutError(request.operation, OPERATION_TIMEOUT_MS)
|
||||
: new ProviderAdapterError("jadx", request.operation, {
|
||||
cause: cause.cause,
|
||||
userMessage:
|
||||
cause.cause instanceof Error
|
||||
? cause.cause.message
|
||||
: String(cause.cause),
|
||||
});
|
||||
const cleanup = new ProviderCleanupError(
|
||||
"jadx",
|
||||
[cause.path],
|
||||
{
|
||||
reason:
|
||||
cause.cleanupCause instanceof Error
|
||||
? cause.cleanupCause.message
|
||||
: String(cause.cleanupCause),
|
||||
...(cause instanceof StableFileHashCleanupFailure &&
|
||||
cause.completedHash !== undefined
|
||||
? { completed_hash: cause.completedHash }
|
||||
: {}),
|
||||
},
|
||||
{ operation: request.operation, cause: cause.cleanupCause },
|
||||
);
|
||||
return analysisErrorWithCleanupFailure(primary, cleanup, request.operation);
|
||||
}
|
||||
if (signal?.aborted === true)
|
||||
return new AnalysisCancelledError(request.operation, { cause });
|
||||
return new AnalysisCancelledError(request.operation);
|
||||
if (timeout.aborted)
|
||||
return new AnalysisTimeoutError(request.operation, OPERATION_TIMEOUT_MS);
|
||||
if (cause instanceof AnalysisError) return cause;
|
||||
@@ -194,73 +156,57 @@ const hashAndroidSource = async (
|
||||
interface PendingCleanup {
|
||||
session: JadxSession | undefined;
|
||||
root: JadxWorkspaceRoot | undefined;
|
||||
readonly fileHandles: Map<
|
||||
OwnedFileHandle,
|
||||
{ readonly path: string; readonly error: AnalysisError }
|
||||
>;
|
||||
readonly previousError: AnalysisError | undefined;
|
||||
}
|
||||
|
||||
const cleanup = async (
|
||||
resources: PendingCleanup,
|
||||
): Promise<Result<void, AnalysisError>> => {
|
||||
const { session, root, previousError, fileHandles } = resources;
|
||||
const { session, root, previousError } = resources;
|
||||
const diagnostics = {
|
||||
previous_error:
|
||||
previousError === undefined ? null : projectAnalysisError(previousError),
|
||||
};
|
||||
const failures: { readonly resource: string; readonly cause: unknown }[] = [];
|
||||
for (const [owner, { path, error }] of fileHandles) {
|
||||
try {
|
||||
await owner.close();
|
||||
error.resolveCleanup();
|
||||
fileHandles.delete(owner);
|
||||
} catch (cause: unknown) {
|
||||
failures.push({ resource: path, cause });
|
||||
}
|
||||
}
|
||||
try {
|
||||
await session?.close();
|
||||
resources.session = undefined;
|
||||
} catch (cause) {
|
||||
failures.push({ resource: session?.transport.runId ?? "unknown", cause });
|
||||
}
|
||||
if (resources.session === undefined && failures.length === 0) {
|
||||
try {
|
||||
await root?.close();
|
||||
resources.root = undefined;
|
||||
} catch (cause: unknown) {
|
||||
failures.push({ resource: root?.path ?? "unknown", cause });
|
||||
}
|
||||
}
|
||||
if (failures.length > 0) {
|
||||
const cleanupCause = new AggregateError(
|
||||
failures.map(({ cause }) => cause),
|
||||
"JADX file, session, or workspace cleanup failed",
|
||||
);
|
||||
// Retain an uncertain workspace until the caller can resolve process ownership.
|
||||
const error = new ProviderCleanupError(
|
||||
"jadx",
|
||||
failures.map(({ resource }) => resource),
|
||||
[
|
||||
session?.transport.runId ?? "unknown",
|
||||
...(root === undefined ? [] : [root.path]),
|
||||
],
|
||||
{
|
||||
...diagnostics,
|
||||
reason: failures
|
||||
.map(({ cause }) =>
|
||||
cause instanceof Error ? cause.message : String(cause),
|
||||
)
|
||||
.join("; "),
|
||||
provider_cleanup: failures.map(({ cause }) =>
|
||||
reason: cause instanceof Error ? cause.message : String(cause),
|
||||
provider_cleanup:
|
||||
cause instanceof ProviderCleanupError
|
||||
? (cause.diagnostics ?? null)
|
||||
: null,
|
||||
),
|
||||
},
|
||||
{
|
||||
cause: previousError ?? cleanupCause,
|
||||
...(previousError?.partialObservation === undefined
|
||||
? {}
|
||||
: { partialObservation: previousError.partialObservation }),
|
||||
},
|
||||
{ cause: previousError ?? cause },
|
||||
);
|
||||
if (previousError?.partialObservation !== undefined)
|
||||
error.retainPartialObservation(previousError.partialObservation);
|
||||
return err(error);
|
||||
}
|
||||
try {
|
||||
await root?.close();
|
||||
resources.root = undefined;
|
||||
} catch (cause) {
|
||||
const error = new ProviderCleanupError(
|
||||
"jadx",
|
||||
[root?.path ?? "unknown"],
|
||||
{
|
||||
...diagnostics,
|
||||
reason: cause instanceof Error ? cause.message : String(cause),
|
||||
},
|
||||
{ cause: previousError ?? cause },
|
||||
);
|
||||
if (previousError?.partialObservation !== undefined)
|
||||
error.retainPartialObservation(previousError.partialObservation);
|
||||
return err(error);
|
||||
}
|
||||
return ok(undefined);
|
||||
@@ -353,7 +299,6 @@ export class JadxProvider implements AndroidAnalysisPort {
|
||||
this.#pendingCleanup = {
|
||||
session: this.#retained.session,
|
||||
root: this.#retained.root,
|
||||
fileHandles: new Map(),
|
||||
previousError: undefined,
|
||||
};
|
||||
this.#retained = undefined;
|
||||
@@ -533,12 +478,6 @@ export class JadxProvider implements AndroidAnalysisPort {
|
||||
signal: options?.signal,
|
||||
session,
|
||||
});
|
||||
const fileHandles: PendingCleanup["fileHandles"] = new Map();
|
||||
if (cause instanceof OwnedRegularFileCleanupFailure)
|
||||
fileHandles.set(cause.owner, {
|
||||
path: cause.path,
|
||||
error: previousError,
|
||||
});
|
||||
const partialObservation = session?.partialObservation();
|
||||
if (partialObservation !== undefined)
|
||||
previousError.retainPartialObservation(partialObservation);
|
||||
@@ -546,7 +485,7 @@ export class JadxProvider implements AndroidAnalysisPort {
|
||||
root ??= this.#retained?.root;
|
||||
session ??= this.#retained?.session;
|
||||
this.#retained = undefined;
|
||||
this.#pendingCleanup = { session, root, fileHandles, previousError };
|
||||
this.#pendingCleanup = { session, root, previousError };
|
||||
const retired = await this.#retire();
|
||||
return retired.ok ? err(previousError) : retired;
|
||||
}
|
||||
|
||||
@@ -290,8 +290,4 @@ export interface AnalysisProviderCandidate extends AnalysisProvider {
|
||||
inspectAvailability(): ProviderAvailability;
|
||||
inspectReadinessSnapshot?(): AnalysisProviderReadinessSnapshot;
|
||||
inspectTargetSupport(target: BinaryTarget): ProviderTargetSupport;
|
||||
/** Report retained candidate-owned cleanup without starting work or retrying it. */
|
||||
hasPendingOwnedResources?(): boolean;
|
||||
/** Release candidate-owned resources that may exist without a client. */
|
||||
closeOwnedResources?(): Promise<Result<null, AnalysisError>>;
|
||||
}
|
||||
@@ -32,46 +32,3 @@ describe("app bundle Info.plist magic", () => {
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("app bundle program directory containment", () => {
|
||||
it("rejects an escaping programs directory before resolving its child", async () => {
|
||||
const root = await mkdtemp(join(tmpdir(), "rea-app-programs-"));
|
||||
try {
|
||||
const bundle = join(root, "Fixture.app");
|
||||
const programs = join(bundle, "Contents", "MacOS");
|
||||
const executable = join(programs, "Missing");
|
||||
const canonicalBundle = join(root, "Canonical.app");
|
||||
const outsidePrograms = join(root, "outside");
|
||||
const plist =
|
||||
"<plist><dict><key>CFBundleExecutable</key><string>Missing</string></dict></plist>";
|
||||
await mkdir(join(bundle, "Contents"), { recursive: true });
|
||||
await writeFile(join(bundle, "Contents", "Info.plist"), plist);
|
||||
let childResolved = false;
|
||||
|
||||
const result = await resolveAppBundleExecutable(bundle, {
|
||||
readFile: async () => Buffer.from(plist),
|
||||
realpath: async (path) => {
|
||||
if (path === bundle) return canonicalBundle;
|
||||
if (path === programs) return outsidePrograms;
|
||||
if (path === executable) {
|
||||
childResolved = true;
|
||||
throw Object.assign(new Error("missing executable"), {
|
||||
code: "ENOENT",
|
||||
});
|
||||
}
|
||||
return path;
|
||||
},
|
||||
});
|
||||
|
||||
expect(result).toMatchObject({
|
||||
ok: false,
|
||||
error: {
|
||||
reason: "app program directory leaves Contents/MacOS",
|
||||
},
|
||||
});
|
||||
expect(childResolved).toBe(false);
|
||||
} finally {
|
||||
await rm(root, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -219,24 +219,11 @@ const resolveLayoutExecutable = async (
|
||||
);
|
||||
const programs = join(bundle, ...layout.programs);
|
||||
const executable = join(programs, name);
|
||||
let canonicalBundle: string;
|
||||
try {
|
||||
canonicalBundle = await fileSystem.realpath(bundle);
|
||||
} catch (cause: unknown) {
|
||||
return err(
|
||||
new BinaryTargetError(bundle, errorReason(cause, bundle), { cause }),
|
||||
);
|
||||
}
|
||||
try {
|
||||
const canonicalPrograms = await fileSystem.realpath(programs);
|
||||
if (!isPathWithinRoot(canonicalBundle, canonicalPrograms))
|
||||
return err(
|
||||
new BinaryTargetError(
|
||||
bundle,
|
||||
`app program directory leaves ${layout.programsLabel}`,
|
||||
),
|
||||
);
|
||||
const canonicalExecutable = await fileSystem.realpath(executable);
|
||||
const [canonicalPrograms, canonicalExecutable] = await Promise.all([
|
||||
fileSystem.realpath(programs),
|
||||
fileSystem.realpath(executable),
|
||||
]);
|
||||
if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
|
||||
return err(
|
||||
new BinaryTargetError(
|
||||
|
||||
@@ -35,8 +35,6 @@ import type { ExecutionOptions } from "./AnalysisProvider.js";
|
||||
|
||||
/** Provider-neutral application boundary for passive browser observation. */
|
||||
export interface BrowserObservationPort {
|
||||
/** Release provider-owned transports during command or server shutdown. */
|
||||
close?(): Promise<void>;
|
||||
identity(): ProviderIdentity;
|
||||
listTargets(
|
||||
input: ListBrowserTargetsInput,
|
||||
|
||||
@@ -1,161 +0,0 @@
|
||||
import { expect, it } from "vitest";
|
||||
import type { BrowserObservationPort } from "./BrowserObservationPort.js";
|
||||
import { listBrowserTargets } from "./BrowserObservationService.js";
|
||||
import type { BrowserTargetList } from "../domain/browserObservationSchemas.js";
|
||||
import { parseEvidence } from "../domain/evidence.js";
|
||||
import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
|
||||
import { BrowserObservationError } from "../domain/browserObservationError.js";
|
||||
import { ok } from "../domain/result.js";
|
||||
import { passiveNetworkCapture } from "../../tests/fixtures/passiveNetworkCapture.js";
|
||||
import { inspectWebPage } from "./BrowserObservationService.js";
|
||||
import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
|
||||
import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
|
||||
import { analyzeWebBundle } from "./BrowserObservationService.js";
|
||||
|
||||
const input = {
|
||||
cdp_endpoint: {
|
||||
transport: "http_discovery" as const,
|
||||
url: "http://127.0.0.1:9222",
|
||||
recorded: "http://127.0.0.1:9222",
|
||||
},
|
||||
allowed_origins: [],
|
||||
};
|
||||
|
||||
const report: BrowserTargetList = {
|
||||
browser: {
|
||||
product: "Chrome",
|
||||
protocol_version: "1.3",
|
||||
revision: "1",
|
||||
user_agent: "Chrome fixture",
|
||||
js_version: "V8 fixture",
|
||||
},
|
||||
targets: [],
|
||||
excluded: { disallowed_origin: 0, unsupported_url: 0, non_page: 0 },
|
||||
limitations: [],
|
||||
};
|
||||
|
||||
const provider = (
|
||||
listTargets: BrowserObservationPort["listTargets"],
|
||||
): BrowserObservationPort =>
|
||||
({
|
||||
identity: () => ({ id: "browser-fixture", name: "Fixture", version: "1" }),
|
||||
listTargets,
|
||||
}) as unknown as BrowserObservationPort;
|
||||
|
||||
it("retains completed browser inventory Evidence when the provider completes after abort", async () => {
|
||||
const controller = new AbortController();
|
||||
const result = await listBrowserTargets(
|
||||
provider(async () => {
|
||||
controller.abort();
|
||||
return ok(report);
|
||||
}),
|
||||
input,
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error._tag).toBe("AnalysisCancelledError");
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "list_browser_targets",
|
||||
normalized_result: report,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("does not let late cancellation hide invalid completed browser output", async () => {
|
||||
const malformed = {
|
||||
...report,
|
||||
limitations: [() => undefined],
|
||||
} as unknown as BrowserTargetList;
|
||||
const output = await listBrowserTargets(
|
||||
provider(async () => ok(malformed)),
|
||||
input,
|
||||
);
|
||||
expect(output).toMatchObject({
|
||||
ok: false,
|
||||
error: { _tag: "AnalysisOutputError" },
|
||||
});
|
||||
if (!output.ok) expect(output.error).toBeInstanceOf(AnalysisOutputError);
|
||||
|
||||
const controller = new AbortController();
|
||||
const late = await listBrowserTargets(
|
||||
provider(async () => {
|
||||
controller.abort();
|
||||
return ok(malformed);
|
||||
}),
|
||||
input,
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
expect(late).toMatchObject({
|
||||
ok: false,
|
||||
error: { _tag: "AnalysisOutputError" },
|
||||
});
|
||||
if (!late.ok) expect(late.error).toBeInstanceOf(AnalysisOutputError);
|
||||
});
|
||||
|
||||
it("converts a raw page inspection retained after browser cleanup failure", async () => {
|
||||
const inspection = passiveNetworkCapture();
|
||||
const failure = new BrowserObservationError(
|
||||
"inspect_web_page",
|
||||
"cleanup_failed",
|
||||
{
|
||||
cleanup: {
|
||||
reason: "target detach failed",
|
||||
resources: ["browser target"],
|
||||
},
|
||||
partialObservation: inspection,
|
||||
},
|
||||
);
|
||||
const browser: BrowserObservationPort = {
|
||||
identity: () => ({ id: "browser-fixture", name: "Fixture", version: "1" }),
|
||||
listTargets: async () => ok(report),
|
||||
inspectPage: async () => ({ ok: false, error: failure }),
|
||||
} as unknown as BrowserObservationPort;
|
||||
const pageInput = inspectWebPageInputSchema.parse({
|
||||
cdp_endpoint: input.cdp_endpoint.recorded,
|
||||
allowed_origins: [],
|
||||
target_id: "page",
|
||||
observation_ms: 0,
|
||||
include_script_sources: false,
|
||||
});
|
||||
const result = await inspectWebPage(browser, pageInput);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error).toBe(failure);
|
||||
expect(result.error.cleanupIncomplete).toBe(true);
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "inspect_web_page",
|
||||
normalized_result: inspection,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("retains captured page Evidence when bundle analysis fails after capture", async () => {
|
||||
const inspection = passiveNetworkCapture();
|
||||
const failure = new BrowserObservationError(
|
||||
"analyze_web_bundle",
|
||||
"cancelled",
|
||||
{ partialObservation: inspection },
|
||||
);
|
||||
const browser = {
|
||||
identity: () => ({ id: "browser-fixture", name: "Fixture", version: "1" }),
|
||||
analyzeBundle: async () => ({ ok: false as const, error: failure }),
|
||||
} as unknown as BrowserObservationPort;
|
||||
const bundleInput = analyzeWebBundleInputSchema.parse({
|
||||
...input,
|
||||
cdp_endpoint: input.cdp_endpoint.recorded,
|
||||
target_id: "page",
|
||||
observation_ms: 0,
|
||||
include_script_sources: true,
|
||||
});
|
||||
const result = await analyzeWebBundle(browser, bundleInput);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error).toBe(failure);
|
||||
expect(failure.operation).toBe("analyze_web_bundle");
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "inspect_web_page",
|
||||
normalized_result: inspection,
|
||||
});
|
||||
}
|
||||
});
|
||||
@@ -14,16 +14,12 @@ import type {
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisCapabilityUnavailableError,
|
||||
AnalysisOutputError,
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import type { AnalysisError } from "../domain/analysisErrorBase.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import type { ExecutionOptions } from "./AnalysisProvider.js";
|
||||
import type { BrowserObservationPort } from "./BrowserObservationPort.js";
|
||||
import { createBrowserEvidence } from "./BrowserEvidence.js";
|
||||
import { jsonValueSchema } from "../domain/jsonValue.js";
|
||||
import { completeProviderEvidence } from "./ProviderOperationExecution.js";
|
||||
import { webPageInspectionSchema } from "../domain/browserObservationSchemas.js";
|
||||
|
||||
/** List browser targets within the endpoint and origin scope in the request. */
|
||||
export const listBrowserTargets = async (
|
||||
@@ -33,16 +29,17 @@ export const listBrowserTargets = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "list_browser_targets");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("list_browser_targets"));
|
||||
const result = await ready.value.listTargets(input, options);
|
||||
if (result.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("list_browser_targets"));
|
||||
return result.ok
|
||||
? browserEvidence(
|
||||
"list_browser_targets",
|
||||
input,
|
||||
result.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
? ok(
|
||||
createBrowserEvidence(
|
||||
"list_browser_targets",
|
||||
input,
|
||||
result.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
)
|
||||
: result;
|
||||
};
|
||||
@@ -55,23 +52,17 @@ export const inspectWebPage = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "inspect_web_page");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("inspect_web_page"));
|
||||
const result = await ready.value.inspectPage(input, options);
|
||||
if (!result.ok)
|
||||
return retainPageInspection(
|
||||
result.error,
|
||||
input,
|
||||
ready.value,
|
||||
"inspect_web_page",
|
||||
);
|
||||
if (result.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("inspect_web_page"));
|
||||
return result.ok
|
||||
? browserEvidence(
|
||||
"inspect_web_page",
|
||||
input,
|
||||
result.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
? ok(
|
||||
createBrowserEvidence(
|
||||
"inspect_web_page",
|
||||
input,
|
||||
result.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
)
|
||||
: result;
|
||||
};
|
||||
@@ -84,22 +75,17 @@ export const analyzeWebBundle = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "analyze_web_bundle");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("analyze_web_bundle"));
|
||||
const analyzed = await ready.value.analyzeBundle(input, options);
|
||||
if (!analyzed.ok)
|
||||
return retainPageInspection(
|
||||
analyzed.error,
|
||||
input,
|
||||
ready.value,
|
||||
if (analyzed.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("analyze_web_bundle"));
|
||||
if (!analyzed.ok) return analyzed;
|
||||
return ok(
|
||||
createBrowserEvidence(
|
||||
"analyze_web_bundle",
|
||||
);
|
||||
return browserEvidence(
|
||||
"analyze_web_bundle",
|
||||
input,
|
||||
analyzed.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
input,
|
||||
analyzed.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
);
|
||||
};
|
||||
|
||||
@@ -111,16 +97,17 @@ export const observeWebSession = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "observe_web_session");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("observe_web_session"));
|
||||
const observed = await ready.value.observeSession(input, options);
|
||||
if (observed.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("observe_web_session"));
|
||||
return observed.ok
|
||||
? browserEvidence(
|
||||
"observe_web_session",
|
||||
input,
|
||||
observed.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
? ok(
|
||||
createBrowserEvidence(
|
||||
"observe_web_session",
|
||||
input,
|
||||
observed.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
)
|
||||
: observed;
|
||||
};
|
||||
@@ -133,16 +120,17 @@ export const discoverWebMcpTools = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "discover_webmcp_tools");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("discover_webmcp_tools"));
|
||||
const discovered = await ready.value.discoverWebMcpTools(input, options);
|
||||
if (discovered.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("discover_webmcp_tools"));
|
||||
return discovered.ok
|
||||
? browserEvidence(
|
||||
"discover_webmcp_tools",
|
||||
input,
|
||||
discovered.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
? ok(
|
||||
createBrowserEvidence(
|
||||
"discover_webmcp_tools",
|
||||
input,
|
||||
discovered.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
)
|
||||
: discovered;
|
||||
};
|
||||
@@ -175,16 +163,17 @@ export const captureWebScreenshot = async (
|
||||
): Promise<Result<Evidence, AnalysisError>> => {
|
||||
const ready = requireBrowser(browser, "capture_web_screenshot");
|
||||
if (!ready.ok) return ready;
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError("capture_web_screenshot"));
|
||||
const captured = await ready.value.captureScreenshot(input, options);
|
||||
if (captured.ok && options.signal?.aborted === true)
|
||||
return err(new AnalysisCancelledError("capture_web_screenshot"));
|
||||
return captured.ok
|
||||
? browserEvidence(
|
||||
"capture_web_screenshot",
|
||||
input,
|
||||
captured.value,
|
||||
ready.value.identity(),
|
||||
options,
|
||||
? ok(
|
||||
createBrowserEvidence(
|
||||
"capture_web_screenshot",
|
||||
input,
|
||||
captured.value,
|
||||
ready.value.identity(),
|
||||
),
|
||||
)
|
||||
: captured;
|
||||
};
|
||||
@@ -222,69 +211,3 @@ const requireBrowser = (
|
||||
),
|
||||
)
|
||||
: ok(browser);
|
||||
|
||||
const browserEvidence = (
|
||||
operation: Parameters<typeof createBrowserEvidence>[0],
|
||||
input: Parameters<typeof createBrowserEvidence>[1],
|
||||
result: Parameters<typeof createBrowserEvidence>[2],
|
||||
provider: Parameters<typeof createBrowserEvidence>[3],
|
||||
options: ExecutionOptions,
|
||||
): Result<Evidence, AnalysisError> => {
|
||||
const json = jsonValueSchema.safeParse(result);
|
||||
if (!json.success)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
operation,
|
||||
"Browser provider returned non-JSON observation data.",
|
||||
{
|
||||
cause: json.error,
|
||||
},
|
||||
),
|
||||
);
|
||||
return completeProviderEvidence(
|
||||
ok(createBrowserEvidence(operation, input, result, provider)),
|
||||
operation,
|
||||
options,
|
||||
);
|
||||
};
|
||||
|
||||
/** Convert a provider-retained page capture without claiming bundle analysis completed. */
|
||||
const retainPageInspection = (
|
||||
error: AnalysisError,
|
||||
input: InspectWebPageInput | AnalyzeWebBundleInput,
|
||||
provider: BrowserObservationPort,
|
||||
errorOperation: "inspect_web_page" | "analyze_web_bundle",
|
||||
): Result<Evidence, AnalysisError> => {
|
||||
const partial = error.partialObservation;
|
||||
if (
|
||||
partial === undefined ||
|
||||
"evidence_id" in partial ||
|
||||
!("target" in partial) ||
|
||||
!("network" in partial) ||
|
||||
!("capture_window" in partial)
|
||||
)
|
||||
return err(error);
|
||||
const inspection = webPageInspectionSchema.safeParse(partial);
|
||||
if (!inspection.success) {
|
||||
if (error instanceof AnalysisCancelledError)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
errorOperation,
|
||||
"Browser provider retained a malformed completed page inspection.",
|
||||
{ cause: inspection.error },
|
||||
),
|
||||
);
|
||||
return err(error);
|
||||
}
|
||||
const pageInput: InspectWebPageInput =
|
||||
"fetch_source_maps" in input
|
||||
? (({ fetch_source_maps: _fetchSourceMaps, ...page }) => page)(input)
|
||||
: input;
|
||||
error.partialObservation = createBrowserEvidence(
|
||||
"inspect_web_page",
|
||||
pageInput,
|
||||
inspection.data,
|
||||
provider.identity(),
|
||||
);
|
||||
return err(error);
|
||||
};
|
||||
@@ -1,78 +0,0 @@
|
||||
import { expect, it } from "vitest";
|
||||
|
||||
import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
|
||||
import { BrowserObservationError } from "../domain/browserObservationError.js";
|
||||
import { parseEvidence } from "../domain/evidence.js";
|
||||
import { browserScenarioInputSchema } from "../domain/browserScenario.js";
|
||||
import { err } from "../domain/result.js";
|
||||
import { scriptScenarioFixture } from "../../tests/fixtures/webScriptCapture.js";
|
||||
import type { BrowserScenarioCapturePort } from "./BrowserScenarioCapturePort.js";
|
||||
import { captureBrowserScenario } from "./BrowserScenarioCaptureService.js";
|
||||
|
||||
const scenario = browserScenarioInputSchema.parse({
|
||||
browser: { mode: "launch", executable_path: "/fixture/chrome" },
|
||||
start_url: { url: "https://fixture.test/", query: [] },
|
||||
actions: [{ step_id: "settle", action: "wait_for_timeout", duration_ms: 1 }],
|
||||
});
|
||||
const capture = scriptScenarioFixture();
|
||||
|
||||
it("converts a retained raw scenario capture into partial Evidence", async () => {
|
||||
const failure = new AnalysisCancelledError("capture_browser_scenario", {
|
||||
partialObservation: {
|
||||
kind: "browser-scenario-observation",
|
||||
capture,
|
||||
},
|
||||
});
|
||||
const provider: BrowserScenarioCapturePort = {
|
||||
identity: () => ({
|
||||
id: "scenario-fixture",
|
||||
name: "Scenario fixture",
|
||||
version: "1",
|
||||
}),
|
||||
captureScenario: async () => err(failure),
|
||||
};
|
||||
const result = await captureBrowserScenario(provider, scenario);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error).toBe(failure);
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "capture_browser_scenario",
|
||||
normalized_result: capture,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("converts a raw scenario capture retained after cleanup failure", async () => {
|
||||
const failure = new BrowserObservationError(
|
||||
"capture_browser_scenario",
|
||||
"cleanup_failed",
|
||||
{
|
||||
cleanup: {
|
||||
reason: "browser close failed",
|
||||
resources: ["browser process"],
|
||||
},
|
||||
partialObservation: {
|
||||
kind: "browser-scenario-observation",
|
||||
capture,
|
||||
},
|
||||
},
|
||||
);
|
||||
const provider: BrowserScenarioCapturePort = {
|
||||
identity: () => ({
|
||||
id: "scenario-fixture",
|
||||
name: "Scenario fixture",
|
||||
version: "1",
|
||||
}),
|
||||
captureScenario: async () => err(failure),
|
||||
};
|
||||
const result = await captureBrowserScenario(provider, scenario);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error).toBe(failure);
|
||||
expect(result.error.cleanupIncomplete).toBe(true);
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "capture_browser_scenario",
|
||||
normalized_result: capture,
|
||||
});
|
||||
}
|
||||
});
|
||||
@@ -1,17 +1,11 @@
|
||||
import type { ExecutionOptions } from "./AnalysisProvider.js";
|
||||
import type { BrowserScenarioCapturePort } from "./BrowserScenarioCapturePort.js";
|
||||
import { createBrowserScenarioEvidence } from "./BrowserScenarioEvidence.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisCapabilityUnavailableError,
|
||||
AnalysisOutputError,
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
|
||||
import type { AnalysisError } from "../domain/analysisErrorBase.js";
|
||||
import type { Evidence } from "../domain/evidence.js";
|
||||
import type { BrowserScenario } from "../domain/browserScenario.js";
|
||||
import { err, type Result } from "../domain/result.js";
|
||||
import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
|
||||
import { completeProviderEvidence } from "./ProviderOperationExecution.js";
|
||||
|
||||
const OPERATION = "capture_browser_scenario" as const;
|
||||
const PROVIDER_ID = "rea-playwright-browser-scenario";
|
||||
@@ -30,55 +24,15 @@ export const captureBrowserScenario = async (
|
||||
"browser scenario provider is not configured",
|
||||
),
|
||||
);
|
||||
if (options.signal?.aborted)
|
||||
return err(new AnalysisCancelledError(OPERATION));
|
||||
const captured = await provider.captureScenario(scenario, options);
|
||||
if (!captured.ok) {
|
||||
const partial = captured.error.partialObservation;
|
||||
if (
|
||||
partial !== undefined &&
|
||||
"kind" in partial &&
|
||||
partial.kind === "browser-scenario-observation"
|
||||
) {
|
||||
const report = browserScenarioCaptureSchema.safeParse(partial.capture);
|
||||
if (!report.success) {
|
||||
if (captured.error instanceof AnalysisCancelledError)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
OPERATION,
|
||||
"Browser scenario provider retained a malformed completed capture.",
|
||||
{ cause: report.error },
|
||||
),
|
||||
);
|
||||
return captured;
|
||||
return captured.ok
|
||||
? {
|
||||
ok: true,
|
||||
value: createBrowserScenarioEvidence(
|
||||
scenario,
|
||||
captured.value,
|
||||
provider.identity(),
|
||||
),
|
||||
}
|
||||
captured.error.partialObservation = createBrowserScenarioEvidence(
|
||||
scenario,
|
||||
report.data,
|
||||
provider.identity(),
|
||||
);
|
||||
}
|
||||
return captured;
|
||||
}
|
||||
const report = browserScenarioCaptureSchema.safeParse(captured.value);
|
||||
if (!report.success)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
OPERATION,
|
||||
"Browser scenario provider returned a malformed completed capture.",
|
||||
{ cause: report.error },
|
||||
),
|
||||
);
|
||||
return completeProviderEvidence(
|
||||
{
|
||||
ok: true,
|
||||
value: createBrowserScenarioEvidence(
|
||||
scenario,
|
||||
report.data,
|
||||
provider.identity(),
|
||||
),
|
||||
},
|
||||
OPERATION,
|
||||
options,
|
||||
);
|
||||
: captured;
|
||||
};
|
||||
@@ -14,14 +14,12 @@ import {
|
||||
} from "./HermesConfigurationYaml.js";
|
||||
import {
|
||||
applyEdits,
|
||||
createScanner,
|
||||
findNodeAtLocation,
|
||||
modify,
|
||||
parse as parseJsonc,
|
||||
parseTree,
|
||||
printParseErrorCode,
|
||||
type ParseError,
|
||||
type SyntaxKind,
|
||||
} from "jsonc-parser";
|
||||
import { z } from "zod";
|
||||
|
||||
@@ -1249,27 +1247,44 @@ const tomlTextHolds = (
|
||||
}
|
||||
};
|
||||
|
||||
// jsonc-parser declares SyntaxKind as an ambient const enum, so keep its token
|
||||
// code local and type-checked as in the JSON scanner used by IDA diagnostics.
|
||||
const JSON_COMMA = 5 satisfies SyntaxKind;
|
||||
|
||||
/** Find the next non-trivia JSONC token at or after `offset`. */
|
||||
const nextJsoncToken = (
|
||||
text: string,
|
||||
offset: number,
|
||||
): { readonly kind: SyntaxKind; readonly offset: number } => {
|
||||
const scanner = createScanner(text, true);
|
||||
scanner.setPosition(offset);
|
||||
const kind = scanner.scan();
|
||||
return { kind, offset: scanner.getTokenOffset() };
|
||||
/** Comments in the trivia between two properties. `undefined` when there are none. */
|
||||
const commentsBetweenProperties = (gap: string): string | undefined => {
|
||||
const pieces: string[] = [];
|
||||
let index = 0;
|
||||
while (index < gap.length) {
|
||||
const line = gap.indexOf("//", index);
|
||||
const block = gap.indexOf("/*", index);
|
||||
if (line < 0 && block < 0) break;
|
||||
const start = line < 0 ? block : block < 0 ? line : Math.min(line, block);
|
||||
const lineComment = start === line;
|
||||
const close = lineComment
|
||||
? gap.indexOf("\n", start)
|
||||
: gap.indexOf("*/", start + 2);
|
||||
if (!lineComment && close < 0) return undefined;
|
||||
const end = lineComment ? (close < 0 ? gap.length : close) : close + 2;
|
||||
const comment = gap.slice(start, end);
|
||||
const lineBreak = gap.lastIndexOf("\n", start - 1);
|
||||
if (lineBreak < 0) pieces.push(` ${comment}`);
|
||||
else {
|
||||
const prefix = gap.slice(lineBreak + 1, start);
|
||||
let indentEnd = 0;
|
||||
while (prefix[indentEnd] === " " || prefix[indentEnd] === "\t")
|
||||
indentEnd += 1;
|
||||
const newline =
|
||||
lineBreak > 0 && gap[lineBreak - 1] === "\r" ? "\r\n" : "\n";
|
||||
pieces.push(`${newline}${prefix.slice(0, indentEnd)}${comment}`);
|
||||
}
|
||||
index = end;
|
||||
}
|
||||
return pieces.length === 0 ? undefined : pieces.join("");
|
||||
};
|
||||
|
||||
/**
|
||||
* Delete a property by its JSONC AST span and the separator needed to keep its
|
||||
* parent object valid. All whitespace and comments outside those tokens stay
|
||||
* byte-for-byte in place.
|
||||
* Delete an object property without taking a comment from the gap before it.
|
||||
* jsonc-parser's removal span includes that gap, so a trailing comment on the
|
||||
* previous property would disappear. Returns `undefined` to keep the stock edit.
|
||||
*/
|
||||
const deleteJsonProperty = (
|
||||
const deleteJsonPropertyPreservingComments = (
|
||||
text: string,
|
||||
path: readonly string[],
|
||||
): string | undefined => {
|
||||
@@ -1286,26 +1301,54 @@ const deleteJsonProperty = (
|
||||
)
|
||||
return undefined;
|
||||
const propertyIndex = parent.children.indexOf(property);
|
||||
if (propertyIndex < 0) return undefined;
|
||||
const previous = parent.children[propertyIndex - 1];
|
||||
const next = parent.children[propertyIndex + 1];
|
||||
let commaOffset: number | undefined;
|
||||
if (previous !== undefined) {
|
||||
const comma = nextJsoncToken(text, previous.offset + previous.length);
|
||||
if (comma.kind !== JSON_COMMA) return undefined;
|
||||
commaOffset = comma.offset;
|
||||
} else {
|
||||
const token = nextJsoncToken(text, property.offset + property.length);
|
||||
if (token.kind === JSON_COMMA) commaOffset = token.offset;
|
||||
else if (next !== undefined) return undefined;
|
||||
if (propertyIndex <= 0 || previous === undefined) return undefined;
|
||||
const comments = commentsBetweenProperties(
|
||||
text.slice(previous.offset + previous.length, property.offset),
|
||||
);
|
||||
if (comments === undefined) return undefined;
|
||||
let removeEnd = property.offset + property.length;
|
||||
const hasNext = parent.children[propertyIndex + 1] !== undefined;
|
||||
if (hasNext) {
|
||||
let comma = removeEnd;
|
||||
while (comma < text.length) {
|
||||
const char = text[comma];
|
||||
if (char === " " || char === "\t" || char === "\r" || char === "\n") {
|
||||
comma += 1;
|
||||
continue;
|
||||
}
|
||||
if (text.startsWith("/*", comma)) {
|
||||
const close = text.indexOf("*/", comma + 2);
|
||||
if (close < 0) return undefined;
|
||||
comma = close + 2;
|
||||
continue;
|
||||
}
|
||||
if (text.startsWith("//", comma)) {
|
||||
while (
|
||||
comma < text.length &&
|
||||
text[comma] !== "\n" &&
|
||||
text[comma] !== "\r"
|
||||
)
|
||||
comma += 1;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (text[comma] !== ",") return undefined;
|
||||
removeEnd = comma + 1;
|
||||
}
|
||||
const edits = [
|
||||
{ offset: property.offset, length: property.length, content: "" },
|
||||
...(commaOffset === undefined
|
||||
? []
|
||||
: [{ offset: commaOffset, length: 1, content: "" }]),
|
||||
];
|
||||
return applyEdits(text, edits);
|
||||
// A line comment runs to the next break. Keep the following token outside it.
|
||||
const remainder = text.slice(removeEnd);
|
||||
let suffix = `${hasNext ? "," : ""}${comments}`;
|
||||
if (
|
||||
suffix.includes("//") &&
|
||||
!suffix.endsWith("\n") &&
|
||||
!suffix.endsWith("\r") &&
|
||||
!remainder.startsWith("\n") &&
|
||||
!remainder.startsWith("\r")
|
||||
)
|
||||
suffix += "\n";
|
||||
return `${text.slice(0, previous.offset + previous.length)}${suffix}${remainder}`;
|
||||
};
|
||||
|
||||
/** Serialize a validated client document, retaining JSONC and TOML comments. */
|
||||
@@ -1334,7 +1377,7 @@ export const serializeClientConfiguration = (
|
||||
return editedPaths.reduce((text, path) => {
|
||||
const value = valueAt(document, path);
|
||||
if (value === undefined) {
|
||||
const preserved = deleteJsonProperty(text, path);
|
||||
const preserved = deleteJsonPropertyPreservingComments(text, path);
|
||||
if (preserved !== undefined) return preserved;
|
||||
}
|
||||
return applyEdits(
|
||||
|
||||
@@ -46,13 +46,10 @@ export const directAnalysisCleanupFailure = (
|
||||
...primary.data,
|
||||
code: "cleanup_incomplete",
|
||||
retryable: false,
|
||||
remediation: cleanup.remediation,
|
||||
details: {
|
||||
// Primary fields describe the original failure; the later close
|
||||
// assessment, including its resources, belongs to cleanup_error.
|
||||
resources: error.cleanupResources.slice(),
|
||||
...primary.data.details,
|
||||
cleanup: "incomplete",
|
||||
resources: error.cleanupResources.slice(),
|
||||
execution_failure:
|
||||
primary.data.details !== undefined &&
|
||||
"execution_failure" in primary.data.details
|
||||
@@ -89,7 +86,6 @@ export const managedAnalysisCleanupFailure = (
|
||||
"close_binary",
|
||||
{
|
||||
cause: error,
|
||||
remediationAction: cleanup.remediation.action,
|
||||
cleanup: { reason: cleanup.message, resources: error.cleanupResources },
|
||||
diagnostics: {
|
||||
cleanup_error: cleanup,
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
import { constants } from "node:fs";
|
||||
import { access, readdir, stat } from "node:fs/promises";
|
||||
import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
|
||||
import type { OwnedFileHandle } from "../filesystem/OwnedFileHandle.js";
|
||||
import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
|
||||
import { join } from "node:path";
|
||||
|
||||
@@ -434,12 +433,9 @@ export interface SystemDoctorHostOptions {
|
||||
readonly architecture?: NodeJS.Architecture;
|
||||
readonly environment?: NodeJS.ProcessEnv;
|
||||
readonly execFileOutput?: typeof execFileOutput;
|
||||
readonly providerInspections?: (
|
||||
adoptFileHandle: (
|
||||
resource: string,
|
||||
handle: OwnedFileHandle,
|
||||
) => Promise<boolean>,
|
||||
) => Promise<readonly DoctorProviderInspection[]>;
|
||||
readonly providerInspections?: () => Promise<
|
||||
readonly DoctorProviderInspection[]
|
||||
>;
|
||||
readonly providerRegistrationEnvironment?: () => Readonly<
|
||||
Record<string, string>
|
||||
>;
|
||||
@@ -553,19 +549,7 @@ export const systemDoctorHost = (
|
||||
manualHopperPaths: () => manualHopperPaths(homeDirectory),
|
||||
...(options.providerInspections === undefined
|
||||
? {}
|
||||
: {
|
||||
providerInspections: () =>
|
||||
options.providerInspections!(
|
||||
async (resource, handle) =>
|
||||
(
|
||||
await resources.release({
|
||||
kind: "file-handle",
|
||||
resource,
|
||||
handle,
|
||||
})
|
||||
).kind === "released",
|
||||
),
|
||||
}),
|
||||
: { providerInspections: options.providerInspections }),
|
||||
...(options.providerRegistrationEnvironment === undefined
|
||||
? {}
|
||||
: {
|
||||
|
||||
@@ -95,6 +95,46 @@ const firstAnalysisCancellation = <Value>(
|
||||
* Direct callers use `execute`; adapters that own validation use
|
||||
* `executeValidated` so an MCP input is parsed exactly once.
|
||||
*/
|
||||
|
||||
const NO_PSEUDOCODE =
|
||||
"The provider reports no pseudocode for this procedure; the batch limitations for procedure_pseudo_code say why.";
|
||||
|
||||
/** One batch item from its pseudocode observation, keeping null distinct from unreadable output. */
|
||||
const batchPseudocodeItem = (
|
||||
address: string,
|
||||
procedure: BatchProcedureIdentity,
|
||||
observed: Result<AnalysisExecution, AnalysisError>,
|
||||
): BatchDecompileItem => {
|
||||
const failed = (error: AnalysisError): BatchDecompileItem => ({
|
||||
address,
|
||||
procedure,
|
||||
status: "error",
|
||||
error: projectAnalysisError(error),
|
||||
});
|
||||
if (!observed.ok) return failed(observed.error);
|
||||
const pseudocode = observed.value.result;
|
||||
// The contract's null is the provider's own answer that this procedure has
|
||||
// no pseudocode (an import slot, a failed body); the provider's reason is
|
||||
// in the batch limitations, so it is not reported as unreadable output.
|
||||
if (pseudocode === null)
|
||||
return failed(
|
||||
new AnalysisCapabilityUnavailableError(
|
||||
observed.value.provider.id,
|
||||
"procedure_pseudo_code",
|
||||
NO_PSEUDOCODE,
|
||||
{ userMessage: NO_PSEUDOCODE },
|
||||
),
|
||||
);
|
||||
if (typeof pseudocode !== "string" || pseudocode.length === 0)
|
||||
return failed(
|
||||
new AnalysisOutputError(
|
||||
"procedure_pseudo_code",
|
||||
"provider returned empty pseudocode",
|
||||
),
|
||||
);
|
||||
return { address, procedure, status: "ok", pseudocode };
|
||||
};
|
||||
|
||||
export class EnhancedTools {
|
||||
constructor(private readonly analysis: AnalysisOperationPort) {}
|
||||
|
||||
@@ -375,7 +415,7 @@ export class EnhancedTools {
|
||||
): Promise<Result<BatchDecompileItem, AnalysisCancelledError>[]> {
|
||||
return Promise.all(
|
||||
ready.map(async ({ address, procedure, providerProcedure }) => {
|
||||
const result = await this.#call(
|
||||
const result = await this.#observe(
|
||||
"procedure_pseudo_code",
|
||||
{ procedure: providerProcedure },
|
||||
signal,
|
||||
@@ -383,32 +423,7 @@ export class EnhancedTools {
|
||||
);
|
||||
if (!result.ok && isAnalysisCancellation(result.error))
|
||||
return err(result.error);
|
||||
const item: BatchDecompileItem = !result.ok
|
||||
? {
|
||||
address,
|
||||
procedure,
|
||||
status: "error",
|
||||
error: projectAnalysisError(result.error),
|
||||
}
|
||||
: typeof result.value !== "string" || result.value.length === 0
|
||||
? {
|
||||
address,
|
||||
procedure,
|
||||
status: "error",
|
||||
error: projectAnalysisError(
|
||||
new AnalysisOutputError(
|
||||
"procedure_pseudo_code",
|
||||
"provider returned empty pseudocode",
|
||||
),
|
||||
),
|
||||
}
|
||||
: {
|
||||
address,
|
||||
procedure,
|
||||
status: "ok",
|
||||
pseudocode: result.value,
|
||||
};
|
||||
return ok(item);
|
||||
return ok(batchPseudocodeItem(address, procedure, result));
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -5,6 +5,7 @@ import { join } from "node:path";
|
||||
import { execFileBoundedOutput } from "../process/ExecFileBoundedOutput.js";
|
||||
import { execFileOutput } from "../process/ExecFileOutput.js";
|
||||
import { downloadHopperPackage } from "./HopperDownload.js";
|
||||
import { hashStableFile } from "../filesystem/StableFileHash.js";
|
||||
import { err, type Result } from "../domain/result.js";
|
||||
import {
|
||||
HOPPER_RELEASES_URL,
|
||||
@@ -431,15 +432,10 @@ export const systemLinuxHopperInstallHost = (
|
||||
!linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`)
|
||||
)
|
||||
return "runtime_dependencies";
|
||||
return (await publisher.hashLauncher(path)).sha256 === expectedSha256
|
||||
return (await hashStableFile(path)).sha256 === expectedSha256
|
||||
? "ready"
|
||||
: "unsupported_hopper_build";
|
||||
} catch (cause: unknown) {
|
||||
if (
|
||||
cause instanceof HopperReleaseError &&
|
||||
cause.reason === "cleanup_failed"
|
||||
)
|
||||
throw cause;
|
||||
// best-effort cleanup: optional launcher probing; unreadable means missing.
|
||||
void cause;
|
||||
return "missing";
|
||||
|
||||
@@ -11,11 +11,6 @@ import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
|
||||
import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import { hashStableFile } from "../filesystem/StableFileHash.js";
|
||||
import {
|
||||
StableFileHashCleanupFailure,
|
||||
type StableFileHashResult,
|
||||
} from "../filesystem/StableFileHash.js";
|
||||
import { OwnedRegularFileCleanupFailure } from "../filesystem/RegularFile.js";
|
||||
import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
|
||||
import { verifyDetachedPgpSignature } from "../process/DetachedPgpSignature.js";
|
||||
import { execFileOutput } from "../process/ExecFileOutput.js";
|
||||
@@ -129,46 +124,6 @@ export class LinuxHopperPublisher {
|
||||
readonly packageFamily: () => Promise<LinuxPackageFamily | undefined>,
|
||||
) {}
|
||||
|
||||
/** Hash a selected launcher while retaining any descriptor cleanup owner. */
|
||||
hashLauncher(path: string): Promise<StableFileHashResult> {
|
||||
return this.#hashStableFile(path);
|
||||
}
|
||||
|
||||
async #hashStableFile(
|
||||
path: string,
|
||||
signal?: AbortSignal,
|
||||
): Promise<StableFileHashResult> {
|
||||
try {
|
||||
return await hashStableFile(path, signal);
|
||||
} catch (cause: unknown) {
|
||||
if (!(cause instanceof OwnedRegularFileCleanupFailure)) throw cause;
|
||||
const cleanup = await this.#resources.release({
|
||||
kind: "file-handle",
|
||||
resource: path,
|
||||
handle: cause.owner,
|
||||
});
|
||||
if (cleanup.kind === "failed") {
|
||||
pendingCleanup.add(this.#resources);
|
||||
throw new HopperReleaseError(
|
||||
"cleanup_failed",
|
||||
`Hopper publisher retained file descriptor cleanup for ${path}.`,
|
||||
{
|
||||
cause: new AggregateError(
|
||||
[cause, cleanup.cause],
|
||||
"Stable file hash and descriptor cleanup failed",
|
||||
{ cause },
|
||||
),
|
||||
},
|
||||
);
|
||||
}
|
||||
if (cause instanceof StableFileHashCleanupFailure) {
|
||||
if (cause.hasPrimaryCause) throw cause.cause;
|
||||
if (cause.completedHash !== undefined) return cause.completedHash;
|
||||
}
|
||||
throw cause;
|
||||
}
|
||||
}
|
||||
|
||||
get cacheRoot(): string {
|
||||
const location = linuxHopperReleaseCacheDirectory(this.environment);
|
||||
if (!location.ok) throw location.error;
|
||||
@@ -338,8 +293,8 @@ export class LinuxHopperPublisher {
|
||||
await this.#withTemporary(async (stage) => {
|
||||
await copyFile(archive, join(stage, "archive"));
|
||||
if (
|
||||
(await this.#hashStableFile(join(stage, "archive"), signal))
|
||||
.sha256 !== verified.packageSha256
|
||||
(await hashStableFile(join(stage, "archive"), signal)).sha256 !==
|
||||
verified.packageSha256
|
||||
)
|
||||
throw new HopperReleaseError(
|
||||
"integrity",
|
||||
@@ -480,12 +435,10 @@ export class LinuxHopperPublisher {
|
||||
signal?: AbortSignal,
|
||||
): Promise<Result<VerifiedLinuxHopperLauncher, HopperReleaseError>> {
|
||||
try {
|
||||
const observed = await this.#hashStableFile(path, signal);
|
||||
const observed = await hashStableFile(path, signal);
|
||||
const cached = await this.#cachedPackage(observed.sha256, signal);
|
||||
if (cached.ok) {
|
||||
if (
|
||||
(await this.#hashStableFile(path, signal)).sha256 !== observed.sha256
|
||||
)
|
||||
if ((await hashStableFile(path, signal)).sha256 !== observed.sha256)
|
||||
return err(
|
||||
new HopperReleaseError(
|
||||
"integrity",
|
||||
@@ -537,7 +490,7 @@ export class LinuxHopperPublisher {
|
||||
if (!verified.ok) throw verified.error;
|
||||
return verified.value;
|
||||
});
|
||||
if ((await this.#hashStableFile(path, signal)).sha256 !== observed.sha256)
|
||||
if ((await hashStableFile(path, signal)).sha256 !== observed.sha256)
|
||||
return err(
|
||||
new HopperReleaseError(
|
||||
"integrity",
|
||||
@@ -730,7 +683,7 @@ export class LinuxHopperPublisher {
|
||||
commandOptions,
|
||||
);
|
||||
return (
|
||||
await this.#hashStableFile(
|
||||
await hashStableFile(
|
||||
join(extracted, "opt", "hopper", "bin", "Hopper"),
|
||||
signal,
|
||||
)
|
||||
|
||||
@@ -1,8 +1,5 @@
|
||||
import { z } from "zod";
|
||||
import type {
|
||||
AnalysisError,
|
||||
AnalysisErrorOptions,
|
||||
} from "../domain/analysisErrorBase.js";
|
||||
import type { AnalysisError } from "../domain/analysisErrorBase.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisInputError,
|
||||
@@ -30,24 +27,6 @@ export interface ProviderOperationPort<
|
||||
): Promise<Result<AnalysisExecution, AnalysisError>>;
|
||||
}
|
||||
|
||||
/** Preserve valid completed Evidence when cancellation arrives at completion. */
|
||||
export const completeProviderEvidence = (
|
||||
completed: Result<Evidence, AnalysisError>,
|
||||
operation: string,
|
||||
options?: ExecutionOptions,
|
||||
errorOptions?: Omit<AnalysisErrorOptions, "partialObservation">,
|
||||
): Result<Evidence, AnalysisError> => {
|
||||
if (!completed.ok) return completed;
|
||||
return options?.signal?.aborted
|
||||
? err(
|
||||
new AnalysisCancelledError(operation, {
|
||||
...errorOptions,
|
||||
partialObservation: completed.value,
|
||||
}),
|
||||
)
|
||||
: completed;
|
||||
};
|
||||
|
||||
/**
|
||||
* Shared CLI/MCP admission, execution, and Evidence composition for
|
||||
* single-request providers. The caller retains its operation vocabulary and
|
||||
@@ -90,5 +69,9 @@ export const executeProviderOperation = async <
|
||||
// the caller no longer wants. The observation it completed is still this
|
||||
// provider's Evidence, so the cancellation carries it as the partial
|
||||
// observation instead of discarding a finished result.
|
||||
return completeProviderEvidence(ok(evidence), operation, options);
|
||||
if (options?.signal?.aborted)
|
||||
return err(
|
||||
new AnalysisCancelledError(operation, { partialObservation: evidence }),
|
||||
);
|
||||
return ok(evidence);
|
||||
};
|
||||
@@ -116,140 +116,3 @@ it("retains Kotlin source identity and language across the inventory projection"
|
||||
expect(parsed.parseFailures).toEqual([]);
|
||||
expect(parsed.relationships).toEqual([]);
|
||||
});
|
||||
|
||||
it("resolves runtime require package mains without an index and before typed indexes", () => {
|
||||
const files = [
|
||||
["main.cjs", 'require("./pkg");\nrequire("./dep");\n'],
|
||||
[
|
||||
"main.ts",
|
||||
'import dep = require("./typed");\n' +
|
||||
'require("./typed");\n' +
|
||||
'import data = require("./json-package");\n' +
|
||||
'require("./emitted.js");\n',
|
||||
],
|
||||
["pkg/package.json", '{"main":"actual.js"}\n'],
|
||||
["pkg/actual.js", 'module.exports = "package main";\n'],
|
||||
["dep.js", 'module.exports = "file";\n'],
|
||||
["dep/index.ts", 'export const value = "index";\n'],
|
||||
["typed.js", 'module.exports = "runtime file";\n'],
|
||||
["typed/index.ts", 'export const value = "source index";\n'],
|
||||
["json-package/package.json", '{"main":"data"}\n'],
|
||||
["json-package/data.json", '{"value":"package main"}\n'],
|
||||
["json-package/index.js", 'module.exports = "fallback index";\n'],
|
||||
["emitted.ts", 'export const value = "source counterpart";\n'],
|
||||
] as const;
|
||||
const read: ReferenceSourceRead = {
|
||||
root: "/selected/source",
|
||||
entries: files.map(([path, content]) => ({
|
||||
status: "read",
|
||||
kind: "file",
|
||||
path,
|
||||
bytes: Buffer.from(content),
|
||||
size: Buffer.byteLength(content),
|
||||
})),
|
||||
bytesRead: files.reduce(
|
||||
(sum, [, content]) => sum + Buffer.byteLength(content),
|
||||
0,
|
||||
),
|
||||
limitations: [],
|
||||
};
|
||||
|
||||
const parsed = parseReferenceSourceEntries(
|
||||
read,
|
||||
new Set(files.map(([path]) => path)),
|
||||
);
|
||||
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.cjs",
|
||||
to: "pkg/actual.js",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.cjs",
|
||||
to: "dep.js",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.ts",
|
||||
to: "typed/index.ts",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.ts",
|
||||
to: "typed.js",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.ts",
|
||||
to: "json-package/data.json",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
expect(parsed.relationships).toContainEqual({
|
||||
from_path: "main.ts",
|
||||
to: "emitted.ts",
|
||||
kind: "requires",
|
||||
resolution: "internal",
|
||||
parse_state: "parsed",
|
||||
});
|
||||
});
|
||||
|
||||
it("matches package manifests by exact or unique canonical directory identity", () => {
|
||||
const composed = "caf\u00e9";
|
||||
const decomposed = "cafe\u0301";
|
||||
const composedTwin = "r\u00e9sum\u00e9";
|
||||
const decomposedTwin = "re\u0301sume\u0301";
|
||||
const files = [
|
||||
[
|
||||
"main.cjs",
|
||||
[composed, composedTwin, decomposedTwin]
|
||||
.map((name) => `require(${JSON.stringify(`./${name}`)});`)
|
||||
.join("\n"),
|
||||
],
|
||||
[`${decomposed}/package.json`, '{"main":"unique.js"}\n'],
|
||||
[`${decomposed}/unique.js`, 'module.exports = "unique";\n'],
|
||||
[`${composed}/unique.js`, 'module.exports = "unrelated exact spelling";\n'],
|
||||
[`${composedTwin}/package.json`, '{"main":"exact-composed.js"}\n'],
|
||||
[`${composedTwin}/exact-composed.js`, 'module.exports = "composed";\n'],
|
||||
[`${decomposedTwin}/package.json`, '{"main":"exact-decomposed.js"}\n'],
|
||||
[
|
||||
`${decomposedTwin}/exact-decomposed.js`,
|
||||
'module.exports = "decomposed";\n',
|
||||
],
|
||||
] as const;
|
||||
const read: ReferenceSourceRead = {
|
||||
root: "/selected/source",
|
||||
entries: files.map(([path, content]) => ({
|
||||
status: "read",
|
||||
kind: "file",
|
||||
path,
|
||||
bytes: Buffer.from(content),
|
||||
size: Buffer.byteLength(content),
|
||||
})),
|
||||
bytesRead: files.reduce(
|
||||
(sum, [, content]) => sum + Buffer.byteLength(content),
|
||||
0,
|
||||
),
|
||||
limitations: [],
|
||||
};
|
||||
|
||||
const parsed = parseReferenceSourceEntries(
|
||||
read,
|
||||
new Set(files.map(([path]) => path)),
|
||||
);
|
||||
|
||||
expect(parsed.relationships.map(({ to }) => to)).toEqual([
|
||||
`${decomposed}/unique.js`,
|
||||
`${composedTwin}/exact-composed.js`,
|
||||
`${decomposedTwin}/exact-decomposed.js`,
|
||||
]);
|
||||
});
|
||||
@@ -107,20 +107,11 @@ type PackageMain =
|
||||
*/
|
||||
const readPackageMains = (
|
||||
read: ReferenceSourceRead,
|
||||
): {
|
||||
readonly mains: ReadonlyMap<string, PackageMain>;
|
||||
readonly pathLookup: ReferenceSourcePathLookup;
|
||||
} => {
|
||||
): ReadonlyMap<string, PackageMain> => {
|
||||
const mains = new Map<string, PackageMain>();
|
||||
const manifestPaths: string[] = [];
|
||||
for (const entry of read.entries) {
|
||||
if (posix.basename(entry.path) !== "package.json") continue;
|
||||
manifestPaths.push(entry.path);
|
||||
const directory = posix.dirname(entry.path);
|
||||
if (mains.has(directory)) {
|
||||
mains.set(directory, { state: "unknown" });
|
||||
continue;
|
||||
}
|
||||
if (entry.status !== "read" || entry.kind !== "file") {
|
||||
mains.set(directory, { state: "unknown" });
|
||||
continue;
|
||||
@@ -143,132 +134,55 @@ const readPackageMains = (
|
||||
mains.set(directory, { state: "unknown" });
|
||||
}
|
||||
}
|
||||
return {
|
||||
mains,
|
||||
pathLookup: createReferenceSourcePathLookup(manifestPaths),
|
||||
};
|
||||
return mains;
|
||||
};
|
||||
|
||||
/**
|
||||
* Extension slots in probe order. Within a slot, files precede directory
|
||||
* indexes. The CommonJS loader tries `X.json` after `X.js` and before any
|
||||
* directory index; ESM and TypeScript require an explicit `.json`.
|
||||
*/
|
||||
const RESOLUTION_SUFFIXES: readonly (readonly string[])[] = [
|
||||
[""],
|
||||
[".ts"],
|
||||
[".js"],
|
||||
[".mjs"],
|
||||
[".cjs"],
|
||||
[".tsx"],
|
||||
[".jsx"],
|
||||
];
|
||||
const REQUIRE_RESOLUTION_SUFFIXES = RESOLUTION_SUFFIXES.map((slot) =>
|
||||
slot.includes(".js") ? [...slot, ".json"] : slot,
|
||||
);
|
||||
const NODE_REQUIRE_SUFFIXES = ["", ".js", ".json", ".node"] as const;
|
||||
|
||||
type InternalSpecifierResolutionMode =
|
||||
| "source-import"
|
||||
| "source-require"
|
||||
| "runtime-require";
|
||||
|
||||
const resolutionSuffixes = (
|
||||
mode: InternalSpecifierResolutionMode,
|
||||
): readonly (readonly string[])[] =>
|
||||
mode === "source-require" ? REQUIRE_RESOLUTION_SUFFIXES : RESOLUTION_SUFFIXES;
|
||||
|
||||
const nodeRequireFileCandidates = (path: string): string[] =>
|
||||
NODE_REQUIRE_SUFFIXES.map((suffix) => `${path}${suffix}`);
|
||||
|
||||
const nodeRequireIndexCandidates = (directory: string): string[] =>
|
||||
NODE_REQUIRE_SUFFIXES.filter((suffix) => suffix !== "").map((suffix) =>
|
||||
posix.join(directory, `index${suffix}`),
|
||||
);
|
||||
const RESOLUTION_SUFFIXES = ["", ".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
|
||||
|
||||
/** Inventory facts an internal specifier resolves against. */
|
||||
interface SpecifierContext {
|
||||
readonly lookupPath: ReferenceSourcePathLookup;
|
||||
readonly packageMains: ReadonlyMap<string, PackageMain>;
|
||||
readonly packageManifestPathLookup: ReferenceSourcePathLookup;
|
||||
}
|
||||
|
||||
const packageMainForDirectory = (
|
||||
directory: string,
|
||||
context: SpecifierContext,
|
||||
): { readonly directory: string; readonly main: PackageMain } | undefined => {
|
||||
const manifestPath = context.packageManifestPathLookup.resolve(
|
||||
posix.join(directory, "package.json"),
|
||||
);
|
||||
if (manifestPath !== undefined) {
|
||||
const manifestDirectory = posix.dirname(manifestPath);
|
||||
const main = context.packageMains.get(manifestDirectory);
|
||||
return main === undefined
|
||||
? undefined
|
||||
: { directory: manifestDirectory, main };
|
||||
}
|
||||
return context.packageManifestPathLookup.has(
|
||||
posix.join(directory, "package.json"),
|
||||
)
|
||||
? { directory, main: { state: "unknown" } }
|
||||
: undefined;
|
||||
};
|
||||
|
||||
/** Apply a package main, retaining an existing index as the fallback target. */
|
||||
/**
|
||||
* Apply a package `main` to a directory resolved through its index. Node loads
|
||||
* the declared entry as a file, then as a directory index, and falls back to
|
||||
* the package's own index only when neither exists.
|
||||
*/
|
||||
const selectPackageMain = (
|
||||
directory: string,
|
||||
indexFallback: string | undefined,
|
||||
index: string,
|
||||
context: SpecifierContext,
|
||||
mode: InternalSpecifierResolutionMode,
|
||||
): { to: string; resolution: "internal" | "unresolved" } => {
|
||||
const packageSelection = packageMainForDirectory(directory, context);
|
||||
const packageDirectory = packageSelection?.directory ?? directory;
|
||||
const manifest = packageSelection?.main;
|
||||
const directory = posix.dirname(index);
|
||||
const manifest = context.packageMains.get(directory);
|
||||
if (manifest === undefined || manifest.state === "none")
|
||||
return indexFallback === undefined
|
||||
? { to: directory, resolution: "unresolved" }
|
||||
: { to: indexFallback, resolution: "internal" };
|
||||
return { to: index, resolution: "internal" };
|
||||
if (manifest.state === "unknown")
|
||||
return { to: packageDirectory, resolution: "unresolved" };
|
||||
return { to: directory, resolution: "unresolved" };
|
||||
// Node resolves `main` with path.resolve: an absolute main leaves the
|
||||
// package, and a trailing separator does not make the entry a directory.
|
||||
if (posix.isAbsolute(manifest.main))
|
||||
return { to: posix.normalize(manifest.main), resolution: "unresolved" };
|
||||
const target = posix
|
||||
.normalize(posix.join(packageDirectory, manifest.main))
|
||||
.normalize(posix.join(directory, manifest.main))
|
||||
.replace(/(?<=.)\/+$/u, "");
|
||||
// Node would load a declared entry outside the imported root.
|
||||
if (logicalPathEscapesRoot(target))
|
||||
return { to: target, resolution: "unresolved" };
|
||||
const slots = resolutionSuffixes(mode);
|
||||
const candidates =
|
||||
mode === "runtime-require"
|
||||
? [
|
||||
...nodeRequireFileCandidates(target),
|
||||
...nodeRequireIndexCandidates(target),
|
||||
]
|
||||
: [
|
||||
...slots.flatMap((slot) =>
|
||||
slot.map((suffix) => `${target}${suffix}`),
|
||||
),
|
||||
...slots
|
||||
.flat()
|
||||
.filter((suffix) => suffix !== "")
|
||||
.map((suffix) => posix.join(target, `index${suffix}`)),
|
||||
];
|
||||
const selected = context.lookupPath.resolveCandidates(candidates);
|
||||
return selected === undefined
|
||||
? indexFallback === undefined
|
||||
? { to: packageDirectory, resolution: "unresolved" }
|
||||
: { to: indexFallback, resolution: "internal" }
|
||||
: { to: selected, resolution: "internal" };
|
||||
const selected = context.lookupPath.resolveCandidates([
|
||||
...RESOLUTION_SUFFIXES.map((suffix) => `${target}${suffix}`),
|
||||
...RESOLUTION_SUFFIXES.filter((suffix) => suffix !== "").map((suffix) =>
|
||||
posix.join(target, `index${suffix}`),
|
||||
),
|
||||
]);
|
||||
return { to: selected ?? index, resolution: "internal" };
|
||||
};
|
||||
|
||||
const resolveInternalSpecifier = (
|
||||
fromPath: string,
|
||||
specifier: string,
|
||||
context: SpecifierContext,
|
||||
mode: InternalSpecifierResolutionMode,
|
||||
): { to: string; resolution: "internal" | "unresolved" } => {
|
||||
if (posix.isAbsolute(specifier))
|
||||
return { to: specifier, resolution: "unresolved" };
|
||||
@@ -282,21 +196,10 @@ const resolveInternalSpecifier = (
|
||||
specifier.endsWith("/") || [".", ".."].includes(posix.basename(specifier));
|
||||
// A directory resolves only to an index with an extension; neither Node nor
|
||||
// TypeScript selects an extensionless `index` file.
|
||||
const slots = resolutionSuffixes(mode);
|
||||
const candidates =
|
||||
mode === "runtime-require"
|
||||
? [
|
||||
...(directoryReference ? [] : nodeRequireFileCandidates(normalized)),
|
||||
...nodeRequireIndexCandidates(normalized),
|
||||
]
|
||||
: slots.flatMap((slot) => [
|
||||
...(directoryReference
|
||||
? []
|
||||
: slot.map((suffix) => `${normalized}${suffix}`)),
|
||||
...slot
|
||||
.filter((suffix) => suffix !== "")
|
||||
.map((suffix) => posix.join(normalized, `index${suffix}`)),
|
||||
]);
|
||||
const candidates = RESOLUTION_SUFFIXES.flatMap((suffix) => [
|
||||
...(directoryReference ? [] : [`${normalized}${suffix}`]),
|
||||
...(suffix === "" ? [] : [posix.join(normalized, `index${suffix}`)]),
|
||||
]);
|
||||
// Retain present runtime files first; substitute only a missing counterpart.
|
||||
// Counterparts cover explicit filenames, not directory/index resolution.
|
||||
if (!directoryReference)
|
||||
@@ -306,15 +209,12 @@ const resolveInternalSpecifier = (
|
||||
),
|
||||
);
|
||||
const match = context.lookupPath.resolveCandidates(candidates);
|
||||
if (match === undefined)
|
||||
return packageMainForDirectory(normalized, context) !== undefined
|
||||
? selectPackageMain(normalized, undefined, context, mode)
|
||||
: { to: normalized, resolution: "unresolved" };
|
||||
if (match === undefined) return { to: normalized, resolution: "unresolved" };
|
||||
const resolvedThroughIndex =
|
||||
posix.basename(match).startsWith("index.") &&
|
||||
posix.dirname(match).normalize("NFC") === normalized.normalize("NFC");
|
||||
return resolvedThroughIndex
|
||||
? selectPackageMain(posix.dirname(match), match, context, mode)
|
||||
? selectPackageMain(match, context)
|
||||
: { to: match, resolution: "internal" };
|
||||
};
|
||||
|
||||
@@ -342,25 +242,17 @@ const appendFile = (
|
||||
});
|
||||
if (parsed === undefined) return;
|
||||
for (const relationship of parsed.relationships) {
|
||||
const { resolutionStrategy, ...graphRelationship } = relationship;
|
||||
if (graphRelationship.resolution !== "internal") {
|
||||
output.relationships.push(graphRelationship);
|
||||
if (relationship.resolution !== "internal") {
|
||||
output.relationships.push(relationship);
|
||||
continue;
|
||||
}
|
||||
const mode: InternalSpecifierResolutionMode =
|
||||
resolutionStrategy === "runtime-require"
|
||||
? "runtime-require"
|
||||
: graphRelationship.kind === "requires"
|
||||
? "source-require"
|
||||
: "source-import";
|
||||
const resolved = resolveInternalSpecifier(
|
||||
graphRelationship.from_path,
|
||||
graphRelationship.to,
|
||||
relationship.from_path,
|
||||
relationship.to,
|
||||
context,
|
||||
mode,
|
||||
);
|
||||
output.relationships.push({
|
||||
...graphRelationship,
|
||||
...relationship,
|
||||
to: resolved.to,
|
||||
resolution: resolved.resolution,
|
||||
});
|
||||
@@ -417,11 +309,9 @@ export const parseReferenceSourceEntries = (
|
||||
parseFailures: [],
|
||||
limitations: [...read.limitations],
|
||||
};
|
||||
const packageMainInventory = readPackageMains(read);
|
||||
const context: SpecifierContext = {
|
||||
lookupPath: createReferenceSourcePathLookup(filePaths),
|
||||
packageMains: packageMainInventory.mains,
|
||||
packageManifestPathLookup: packageMainInventory.pathLookup,
|
||||
packageMains: readPackageMains(read),
|
||||
};
|
||||
for (const entry of read.entries) {
|
||||
if (signal?.aborted === true) break;
|
||||
|
||||
@@ -159,10 +159,10 @@ const claudeDesktopLocation = (
|
||||
};
|
||||
|
||||
const claudeCodeConfigDirectory = ({ home, env }: ClientPathContext): string =>
|
||||
env.CLAUDE_CONFIG_DIR || home;
|
||||
env.CLAUDE_CONFIG_DIR ?? home;
|
||||
|
||||
const claudeCodeMarkerDirectory = ({ home, env }: ClientPathContext): string =>
|
||||
env.CLAUDE_CONFIG_DIR || join(home, ".claude");
|
||||
env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
|
||||
|
||||
const codexDirectory = ({ home, env }: ClientPathContext): string =>
|
||||
env.CODEX_HOME || join(home, ".codex");
|
||||
@@ -486,8 +486,8 @@ export const SUPPORTED_CLIENT_DEFINITIONS = [
|
||||
{
|
||||
name: "claude_code",
|
||||
displayName: "Claude Code",
|
||||
skillPath: (context: ClientPathContext) =>
|
||||
join(claudeCodeMarkerDirectory(context), "skills"),
|
||||
skillPath: ({ home, env }: ClientPathContext) =>
|
||||
join(env.CLAUDE_CONFIG_DIR ?? join(home, ".claude"), "skills"),
|
||||
configPath: (context: ClientPathContext) =>
|
||||
join(claudeCodeConfigDirectory(context), ".claude.json"),
|
||||
markerPath: claudeCodeMarkerDirectory,
|
||||
|
||||
@@ -4,10 +4,6 @@ import { historicalHar } from "../../tests/fixtures/historicalHar.js";
|
||||
import { ok } from "../domain/result.js";
|
||||
import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
|
||||
import { parseEvidence } from "../domain/evidence.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisOutputError,
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import {
|
||||
webNetworkCaptureSchema,
|
||||
type WebNetworkCapture,
|
||||
@@ -129,43 +125,6 @@ it("rejects an adapter omitting its original observed digest before caller proje
|
||||
if (!result.ok) expect(result.error._tag).toBe("AnalysisOutputError");
|
||||
});
|
||||
|
||||
it("retains valid completed capture Evidence on late cancellation and preserves invalid output", async () => {
|
||||
const controller = new AbortController();
|
||||
const report = fixture();
|
||||
const late = await new WebNetworkCaptureService({
|
||||
inspect: () => {
|
||||
controller.abort();
|
||||
return Promise.resolve(ok(report));
|
||||
},
|
||||
}).inspect(
|
||||
{ capture_path: report.artifact.path, format: "har" },
|
||||
{ signal: controller.signal },
|
||||
);
|
||||
expect(late.ok).toBe(false);
|
||||
if (!late.ok) {
|
||||
expect(late.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(parseEvidence(late.error.partialObservation)).toMatchObject({
|
||||
operation: "inspect_web_network_capture",
|
||||
normalized_result: expect.objectContaining({ total_records: 1 }),
|
||||
});
|
||||
}
|
||||
|
||||
const malformed = fixture();
|
||||
malformed.artifact.path = "/other.har";
|
||||
const outputController = new AbortController();
|
||||
const invalid = await new WebNetworkCaptureService({
|
||||
inspect: () => {
|
||||
outputController.abort();
|
||||
return Promise.resolve(ok(malformed));
|
||||
},
|
||||
}).inspect(
|
||||
{ capture_path: "/capture.har", format: "har" },
|
||||
{ signal: outputController.signal },
|
||||
);
|
||||
expect(invalid.ok).toBe(false);
|
||||
if (!invalid.ok) expect(invalid.error).toBeInstanceOf(AnalysisOutputError);
|
||||
});
|
||||
|
||||
it.each([
|
||||
["producer"],
|
||||
["artifact"],
|
||||
|
||||
@@ -20,7 +20,6 @@ import {
|
||||
captureSensitiveValues,
|
||||
webNetworkCaptureSchema,
|
||||
} from "../domain/webNetworkCapture.js";
|
||||
import { completeProviderEvidence } from "./ProviderOperationExecution.js";
|
||||
|
||||
const OPERATION = "inspect_web_network_capture";
|
||||
|
||||
@@ -75,6 +74,8 @@ export class WebNetworkCaptureService {
|
||||
);
|
||||
const loaded = await this.port.inspect(input, options);
|
||||
if (!loaded.ok) return failure(loaded.error);
|
||||
if (options?.signal?.aborted)
|
||||
return failure(new AnalysisCancelledError(OPERATION));
|
||||
const report = webNetworkCaptureSchema.safeParse(loaded.value);
|
||||
if (!report.success)
|
||||
return failure(
|
||||
@@ -158,55 +159,45 @@ export class WebNetworkCaptureService {
|
||||
record_ordinals: selected,
|
||||
sensitive_value_count: input.sensitive_values.length,
|
||||
});
|
||||
return completeProviderEvidence(
|
||||
ok(
|
||||
createEvidence(
|
||||
safeSha256 === null
|
||||
? undefined
|
||||
: {
|
||||
path: safePath,
|
||||
sha256: safeSha256,
|
||||
format: "file",
|
||||
},
|
||||
value.decoder,
|
||||
{
|
||||
operation: OPERATION,
|
||||
parameters,
|
||||
result: {
|
||||
...safeValue,
|
||||
artifact: {
|
||||
...value.artifact,
|
||||
path: safePath,
|
||||
sha256: safeSha256,
|
||||
},
|
||||
records,
|
||||
limitations:
|
||||
safeSha256 === null
|
||||
? [...limitations, subjectUnavailableReason]
|
||||
: limitations,
|
||||
return ok(
|
||||
createEvidence(
|
||||
safeSha256 === null
|
||||
? undefined
|
||||
: {
|
||||
path: safePath,
|
||||
sha256: safeSha256,
|
||||
format: "file",
|
||||
},
|
||||
...(safeValue.format !== "qlog"
|
||||
? {}
|
||||
: {
|
||||
analysisProfile: createAnalysisProfile(value.decoder, {
|
||||
qlog_profile: safeValue.qlog.profile,
|
||||
clock: safeValue.qlog.clock,
|
||||
scope: safeValue.qlog.scope,
|
||||
}),
|
||||
}),
|
||||
confidence: "observed",
|
||||
authority: "historical-reference",
|
||||
limitations,
|
||||
...(safeSha256 === null ? { subjectUnavailableReason } : {}),
|
||||
locations:
|
||||
safePath === ""
|
||||
? []
|
||||
: [{ kind: "artifact-path", path: safePath }],
|
||||
value.decoder,
|
||||
{
|
||||
operation: OPERATION,
|
||||
parameters,
|
||||
result: {
|
||||
...safeValue,
|
||||
artifact: { ...value.artifact, path: safePath, sha256: safeSha256 },
|
||||
records,
|
||||
limitations:
|
||||
safeSha256 === null
|
||||
? [...limitations, subjectUnavailableReason]
|
||||
: limitations,
|
||||
},
|
||||
),
|
||||
...(safeValue.format !== "qlog"
|
||||
? {}
|
||||
: {
|
||||
analysisProfile: createAnalysisProfile(value.decoder, {
|
||||
qlog_profile: safeValue.qlog.profile,
|
||||
clock: safeValue.qlog.clock,
|
||||
scope: safeValue.qlog.scope,
|
||||
}),
|
||||
}),
|
||||
confidence: "observed",
|
||||
authority: "historical-reference",
|
||||
limitations,
|
||||
...(safeSha256 === null ? { subjectUnavailableReason } : {}),
|
||||
locations:
|
||||
safePath === "" ? [] : [{ kind: "artifact-path", path: safePath }],
|
||||
},
|
||||
),
|
||||
OPERATION,
|
||||
options,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -12,8 +12,6 @@ import type {
|
||||
|
||||
/** Provider-neutral live source attribution operations with distinct instrumentation authority. */
|
||||
export interface WebRuntimePort {
|
||||
/** Release provider-owned transports during command or server shutdown. */
|
||||
close?(): Promise<void>;
|
||||
identity(): ProviderIdentity;
|
||||
observeExecution(
|
||||
input: ObserveWebExecutionInput,
|
||||
|
||||
@@ -2,14 +2,10 @@ import { expect, it } from "vitest";
|
||||
import { WebRuntimeService } from "./WebRuntimeService.js";
|
||||
import {
|
||||
recordingWebRuntimePort,
|
||||
webExecutionFixture,
|
||||
webListenersFixture,
|
||||
} from "./WebRuntimeService.fixture.js";
|
||||
import { err, ok } from "../domain/result.js";
|
||||
import { AnalysisTimeoutError } from "../domain/analysisErrorCore.js";
|
||||
import { ProviderCleanupError } from "../domain/providerCleanupError.js";
|
||||
import { parseEvidence } from "../domain/evidence.js";
|
||||
import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
|
||||
|
||||
it("rejects malformed input and prior cancellation without calling a provider", async () => {
|
||||
const provider = recordingWebRuntimePort();
|
||||
@@ -63,92 +59,3 @@ it("preserves actual provider failures and rejects changed target/selector ident
|
||||
if (changed.ok) throw new Error("Changed selection must be rejected");
|
||||
expect(changed.error._tag).toBe("AnalysisOutputError");
|
||||
});
|
||||
|
||||
it("converts raw execution retained by provider cleanup failure into partial Evidence", async () => {
|
||||
const args = {
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
target_id: "selected-page",
|
||||
observation_ms: 5,
|
||||
};
|
||||
const execution = webExecutionFixture(args.target_id, args.observation_ms);
|
||||
const failure = new ProviderCleanupError(
|
||||
"rea-cdp-browser",
|
||||
["selected-page"],
|
||||
{ reason: "target detach failed" },
|
||||
{ operation: "observe_web_execution", partialObservation: execution },
|
||||
);
|
||||
const result = await new WebRuntimeService({
|
||||
identity: () => ({
|
||||
id: "web-runtime",
|
||||
name: "Runtime fixture",
|
||||
version: "1",
|
||||
}),
|
||||
observeExecution: async () => err(failure),
|
||||
inspectEventListeners: async () => err(failure),
|
||||
}).observe(args);
|
||||
expect(result.ok).toBe(false);
|
||||
if (!result.ok) {
|
||||
expect(result.error).toBe(failure);
|
||||
expect(result.error.cleanupIncomplete).toBe(true);
|
||||
expect(parseEvidence(result.error.partialObservation)).toMatchObject({
|
||||
operation: "observe_web_execution",
|
||||
normalized_result: execution,
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it("retains completed execution Evidence on late abort and keeps invalid output primary", async () => {
|
||||
const input = {
|
||||
cdp_endpoint: "http://127.0.0.1:9222",
|
||||
target_id: "selected-page",
|
||||
observation_ms: 5,
|
||||
};
|
||||
const unused = new AnalysisTimeoutError(
|
||||
"inspect_web_event_listeners",
|
||||
20_000,
|
||||
);
|
||||
const controller = new AbortController();
|
||||
const completed = await new WebRuntimeService({
|
||||
identity: () => ({
|
||||
id: "web-runtime",
|
||||
name: "Runtime fixture",
|
||||
version: "1",
|
||||
}),
|
||||
observeExecution: async () => {
|
||||
controller.abort();
|
||||
return ok(webExecutionFixture(input.target_id, input.observation_ms));
|
||||
},
|
||||
inspectEventListeners: async () => err(unused),
|
||||
}).observe(input, { signal: controller.signal });
|
||||
expect(completed.ok).toBe(false);
|
||||
if (!completed.ok)
|
||||
expect(parseEvidence(completed.error.partialObservation)).toMatchObject({
|
||||
operation: "observe_web_execution",
|
||||
normalized_result: webExecutionFixture(
|
||||
input.target_id,
|
||||
input.observation_ms,
|
||||
),
|
||||
});
|
||||
|
||||
const late = new AbortController();
|
||||
const invalid = await new WebRuntimeService({
|
||||
identity: () => ({
|
||||
id: "web-runtime",
|
||||
name: "Runtime fixture",
|
||||
version: "1",
|
||||
}),
|
||||
observeExecution: async () => {
|
||||
late.abort();
|
||||
return ok(webExecutionFixture(input.target_id, input.observation_ms));
|
||||
},
|
||||
inspectEventListeners: async () => err(unused),
|
||||
}).observe(
|
||||
{ ...input, allowed_origins: ["https://allowed.example"] },
|
||||
{ signal: late.signal },
|
||||
);
|
||||
expect(invalid).toMatchObject({
|
||||
ok: false,
|
||||
error: { _tag: "AnalysisOutputError" },
|
||||
});
|
||||
if (!invalid.ok) expect(invalid.error).toBeInstanceOf(AnalysisOutputError);
|
||||
});
|
||||
@@ -7,7 +7,7 @@ import {
|
||||
AnalysisOutputError,
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import { createEvidence, type Evidence } from "../domain/evidence.js";
|
||||
import { jsonObjectSchema } from "../domain/jsonValue.js";
|
||||
import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
|
||||
import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
|
||||
import { err, ok, type Result } from "../domain/result.js";
|
||||
import {
|
||||
@@ -18,7 +18,6 @@ import {
|
||||
inspectWebEventListenersInputSchema,
|
||||
webEventListenersSchema,
|
||||
} from "../domain/webEventListeners.js";
|
||||
import { completeProviderEvidence } from "./ProviderOperationExecution.js";
|
||||
|
||||
/** Shared public workflows keep instrumentation and listener inspection independently selectable. */
|
||||
export class WebRuntimeService {
|
||||
@@ -38,35 +37,7 @@ export class WebRuntimeService {
|
||||
);
|
||||
if (!parsed.ok) return parsed;
|
||||
const result = await this.provider.observeExecution(parsed.value, options);
|
||||
if (!result.ok) {
|
||||
const partial = result.error.partialObservation;
|
||||
if (
|
||||
partial !== undefined &&
|
||||
!("evidence_id" in partial) &&
|
||||
"instrumentation" in partial &&
|
||||
"window" in partial
|
||||
) {
|
||||
const verifiedPartial = webExecutionSchema.safeParse(partial);
|
||||
if (verifiedPartial.success) {
|
||||
const evidence = this.evidence(
|
||||
operation,
|
||||
parsed.value,
|
||||
verifiedPartial.data,
|
||||
);
|
||||
if (evidence.ok) result.error.partialObservation = evidence.value;
|
||||
else if (result.error instanceof AnalysisCancelledError)
|
||||
return evidence;
|
||||
} else if (result.error instanceof AnalysisCancelledError)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
operation,
|
||||
"Provider retained a malformed completed execution observation.",
|
||||
{ cause: verifiedPartial.error },
|
||||
),
|
||||
);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
if (!result.ok) return result;
|
||||
const verified = webExecutionSchema.safeParse(result.value);
|
||||
if (!verified.success)
|
||||
return err(new AnalysisOutputError(operation, verified.error.message));
|
||||
@@ -100,35 +71,7 @@ export class WebRuntimeService {
|
||||
parsed.value,
|
||||
options,
|
||||
);
|
||||
if (!result.ok) {
|
||||
const partial = result.error.partialObservation;
|
||||
if (
|
||||
partial !== undefined &&
|
||||
!("evidence_id" in partial) &&
|
||||
"selected_node" in partial &&
|
||||
"listeners" in partial
|
||||
) {
|
||||
const verifiedPartial = webEventListenersSchema.safeParse(partial);
|
||||
if (verifiedPartial.success) {
|
||||
const evidence = this.evidence(
|
||||
operation,
|
||||
parsed.value,
|
||||
verifiedPartial.data,
|
||||
);
|
||||
if (evidence.ok) result.error.partialObservation = evidence.value;
|
||||
else if (result.error instanceof AnalysisCancelledError)
|
||||
return evidence;
|
||||
} else if (result.error instanceof AnalysisCancelledError)
|
||||
return err(
|
||||
new AnalysisOutputError(
|
||||
operation,
|
||||
"Provider retained malformed completed event-listener data.",
|
||||
{ cause: verifiedPartial.error },
|
||||
),
|
||||
);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
if (!result.ok) return result;
|
||||
const verified = webEventListenersSchema.safeParse(result.value);
|
||||
if (!verified.success)
|
||||
return err(new AnalysisOutputError(operation, verified.error.message));
|
||||
@@ -155,6 +98,8 @@ export class WebRuntimeService {
|
||||
| z.infer<typeof webEventListenersSchema>,
|
||||
options?: ExecutionOptions,
|
||||
): Result<Evidence, AnalysisError> {
|
||||
if (options?.signal?.aborted)
|
||||
return err(new AnalysisCancelledError(operation));
|
||||
if (
|
||||
input.allowed_origins.length > 0 &&
|
||||
!input.allowed_origins.includes(result.target.origin)
|
||||
@@ -165,20 +110,16 @@ export class WebRuntimeService {
|
||||
"Provider returned a document outside the selected origin scope.",
|
||||
),
|
||||
);
|
||||
return completeProviderEvidence(
|
||||
ok(
|
||||
createEvidence(undefined, this.provider.identity(), {
|
||||
predicateType: `rea.${operation.replaceAll("_", "-")}`,
|
||||
operation,
|
||||
parameters: jsonObjectSchema.parse(input),
|
||||
result,
|
||||
confidence: "observed",
|
||||
authority: "external-service",
|
||||
limitations: result.limitations,
|
||||
}),
|
||||
),
|
||||
operation,
|
||||
options,
|
||||
return ok(
|
||||
createEvidence(undefined, this.provider.identity(), {
|
||||
predicateType: `rea.${operation.replaceAll("_", "-")}`,
|
||||
operation,
|
||||
parameters: jsonObjectSchema.parse(input),
|
||||
result: jsonValueSchema.parse(result),
|
||||
confidence: "observed",
|
||||
authority: "external-service",
|
||||
limitations: result.limitations,
|
||||
}),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,11 +5,6 @@ import {
|
||||
webSourceMapDecoderFixture as decoder,
|
||||
} from "../../tests/fixtures/webSourceLocation.js";
|
||||
import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
|
||||
import { parseEvidence } from "../domain/evidence.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisOutputError,
|
||||
} from "../domain/analysisErrorCore.js";
|
||||
import { ok } from "../domain/result.js";
|
||||
import { webSourceLocationResultSchema } from "../domain/webSourceLocation.js";
|
||||
import { WebSourceLocationService } from "./WebSourceLocationService.js";
|
||||
@@ -164,42 +159,5 @@ it("honors cancellation both before acquisition and across decoder completion",
|
||||
},
|
||||
}).trace(args, { signal: controller.signal });
|
||||
if (late.ok) throw new Error("expected cancellation");
|
||||
expect(late.error).toBeInstanceOf(AnalysisCancelledError);
|
||||
expect(parseEvidence(late.error.partialObservation)).toMatchObject({
|
||||
operation: "trace_web_source_location",
|
||||
confidence: "derived",
|
||||
});
|
||||
|
||||
const malformedDecoder: WebSourceMapPort = {
|
||||
trace: async (input, options) => {
|
||||
const decoded = await decoder.trace(input, options);
|
||||
return decoded.ok
|
||||
? ok({ ...decoded.value, source_map_sha256: "b".repeat(64) })
|
||||
: decoded;
|
||||
},
|
||||
};
|
||||
const malformed = await new WebSourceLocationService(
|
||||
{ load: () => Promise.resolve(ok(webSourceLocationFixture())) },
|
||||
malformedDecoder,
|
||||
).trace(args);
|
||||
expect(malformed.ok).toBe(false);
|
||||
if (!malformed.ok)
|
||||
expect(malformed.error).toBeInstanceOf(AnalysisOutputError);
|
||||
|
||||
const invalidController = new AbortController();
|
||||
const malformedLate = await new WebSourceLocationService(
|
||||
{ load: () => Promise.resolve(ok(webSourceLocationFixture())) },
|
||||
{
|
||||
trace: async (input, options) => {
|
||||
const decoded = await decoder.trace(input, options);
|
||||
invalidController.abort();
|
||||
return decoded.ok
|
||||
? ok({ ...decoded.value, source_map_sha256: "b".repeat(64) })
|
||||
: decoded;
|
||||
},
|
||||
},
|
||||
).trace(args, { signal: invalidController.signal });
|
||||
expect(malformedLate.ok).toBe(false);
|
||||
if (!malformedLate.ok)
|
||||
expect(malformedLate.error).toBeInstanceOf(AnalysisOutputError);
|
||||
expect(late.error._tag).toBe("AnalysisCancelledError");
|
||||
});
|
||||
@@ -34,7 +34,6 @@ import type {
|
||||
WebSourceLocationArtifactPort,
|
||||
WebSourceMapPort,
|
||||
} from "./WebSourceLocationPorts.js";
|
||||
import { completeProviderEvidence } from "./ProviderOperationExecution.js";
|
||||
|
||||
const OPERATION = "trace_web_source_location";
|
||||
const artifactsSchema = selectedWebScriptArtifactsSchema.extend({
|
||||
@@ -127,6 +126,8 @@ export class WebSourceLocationService {
|
||||
if (!traced.ok) return traced;
|
||||
const report = verifyReport(input, map.file.sha256, traced.value);
|
||||
if (!report.ok) return report;
|
||||
if (options?.signal?.aborted)
|
||||
return err(new AnalysisCancelledError(OPERATION));
|
||||
const limitations = [
|
||||
...LIMITATIONS,
|
||||
codecBudgetLimitation(report.value.runtime),
|
||||
@@ -146,41 +147,37 @@ export class WebSourceLocationService {
|
||||
limitations,
|
||||
});
|
||||
if (!normalized.success) return invalidOutput(normalized.error.message);
|
||||
return completeProviderEvidence(
|
||||
ok(
|
||||
createEvidence(
|
||||
{
|
||||
path: data.sourceFile.path,
|
||||
sha256: data.sourceFile.sha256,
|
||||
format: "file",
|
||||
},
|
||||
{
|
||||
id: "rea-web-source-location",
|
||||
name: "REA captured source-map point trace",
|
||||
version: "1",
|
||||
},
|
||||
{
|
||||
operation: OPERATION,
|
||||
parameters: jsonObjectSchema.parse(input),
|
||||
result: normalized.data,
|
||||
rawResult: { source_map_text: map.text },
|
||||
confidence: "derived",
|
||||
authority: "historical-reference",
|
||||
limitations,
|
||||
locations: [
|
||||
data.sourceFile.path,
|
||||
data.manifestFile.path,
|
||||
map.file.path,
|
||||
].map((path) => ({ kind: "artifact-path", path })),
|
||||
evidenceLinks:
|
||||
data.manifest.source_evidence_id === null
|
||||
? []
|
||||
: [data.manifest.source_evidence_id],
|
||||
},
|
||||
),
|
||||
return ok(
|
||||
createEvidence(
|
||||
{
|
||||
path: data.sourceFile.path,
|
||||
sha256: data.sourceFile.sha256,
|
||||
format: "file",
|
||||
},
|
||||
{
|
||||
id: "rea-web-source-location",
|
||||
name: "REA captured source-map point trace",
|
||||
version: "1",
|
||||
},
|
||||
{
|
||||
operation: OPERATION,
|
||||
parameters: jsonObjectSchema.parse(input),
|
||||
result: normalized.data,
|
||||
rawResult: { source_map_text: map.text },
|
||||
confidence: "derived",
|
||||
authority: "historical-reference",
|
||||
limitations,
|
||||
locations: [
|
||||
data.sourceFile.path,
|
||||
data.manifestFile.path,
|
||||
map.file.path,
|
||||
].map((path) => ({ kind: "artifact-path", path })),
|
||||
evidenceLinks:
|
||||
data.manifest.source_evidence_id === null
|
||||
? []
|
||||
: [data.manifest.source_evidence_id],
|
||||
},
|
||||
),
|
||||
OPERATION,
|
||||
options,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -224,9 +224,6 @@ const createAnalysisViewEvidence = (
|
||||
: "derived",
|
||||
authority: parent.authority,
|
||||
limitations: result.limitations,
|
||||
...(result.kind === "native" && parent.relationship_coverage !== null
|
||||
? { relationshipCoverage: parent.relationship_coverage }
|
||||
: {}),
|
||||
locations: [
|
||||
...(result.artifact.path.length > 0
|
||||
? [{ kind: "artifact-path" as const, path: result.artifact.path }]
|
||||
|
||||
@@ -7,7 +7,6 @@ import type { AnalysisProfileCommitment } from "../../domain/analysisProfile.js"
|
||||
import type { BinaryTarget } from "../../domain/binaryTargetTypes.js";
|
||||
import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
|
||||
import type { AnalysisError } from "../../domain/analysisErrorBase.js";
|
||||
import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
|
||||
import {
|
||||
ProviderSelectionError,
|
||||
type ProviderSelectionFailureReason,
|
||||
@@ -136,35 +135,6 @@ export class AnalysisProviderRegistry {
|
||||
);
|
||||
}
|
||||
|
||||
/** Report retained candidate resources without retrying cleanup. */
|
||||
hasPendingOwnedResources(): boolean {
|
||||
return this.#providers.some(
|
||||
(provider) => provider.hasPendingOwnedResources?.() === true,
|
||||
);
|
||||
}
|
||||
|
||||
/** Close candidate-owned resources even when no target client was opened. */
|
||||
async closeOwnedResources(): Promise<Result<null, AnalysisError>> {
|
||||
const failures: AnalysisError[] = [];
|
||||
for (const provider of this.#providers) {
|
||||
if (provider.closeOwnedResources === undefined) continue;
|
||||
const result = await provider.closeOwnedResources();
|
||||
if (!result.ok) failures.push(result.error);
|
||||
}
|
||||
if (failures.length === 0) return ok(null);
|
||||
if (failures.length === 1) return err(failures[0]!);
|
||||
return err(
|
||||
new ProviderCleanupError(
|
||||
"rea",
|
||||
failures.flatMap((failure) => failure.cleanupResources),
|
||||
{
|
||||
reason: failures.map((failure) => failure.message).join("; "),
|
||||
},
|
||||
{ cause: new AggregateError(failures) },
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
/** List the unique deep-operation declarations without probing candidates. */
|
||||
declaredOperations(): readonly string[] {
|
||||
return [...this.#declaredOperations];
|
||||
|
||||
@@ -55,15 +55,12 @@ const ENHANCED_OPERATIONS: ReadonlySet<string> = new Set(
|
||||
ENHANCED_TOOL_CONTRACTS.map(({ name }) => name),
|
||||
);
|
||||
|
||||
interface SessionRun {
|
||||
interface SessionBinding {
|
||||
readonly target: BinaryTarget;
|
||||
readonly client: AnalysisClient;
|
||||
readonly profile: AnalysisProfileCommitment | null;
|
||||
readonly route: SessionProviderRoute;
|
||||
readonly runId: string;
|
||||
}
|
||||
|
||||
interface SessionBinding extends SessionRun {
|
||||
readonly target: BinaryTarget;
|
||||
readonly profile: AnalysisProfileCommitment | null;
|
||||
nativeSourceAdmitted: boolean;
|
||||
}
|
||||
|
||||
@@ -82,7 +79,8 @@ export class BinarySession
|
||||
#externalMutationCleanupFailure: AnalysisError | undefined;
|
||||
#pendingCleanup:
|
||||
| {
|
||||
readonly run: SessionRun;
|
||||
readonly client: AnalysisClient;
|
||||
readonly providerId: string;
|
||||
readonly retainDocument: boolean;
|
||||
}
|
||||
| undefined;
|
||||
@@ -320,7 +318,10 @@ export class BinarySession
|
||||
const previous = this.#active;
|
||||
this.#active = undefined;
|
||||
if (previous !== undefined) {
|
||||
const closed = await this.#retireClient(previous);
|
||||
const closed = await this.#retireClient(
|
||||
previous.client,
|
||||
previous.route.identity.id,
|
||||
);
|
||||
if (!closed.ok) {
|
||||
// A failed open retires the provider cache, not the investigation.
|
||||
// Preserve Evidence and Unknown history for export and recovery.
|
||||
@@ -338,15 +339,22 @@ export class BinarySession
|
||||
);
|
||||
const runId = randomUUID();
|
||||
const client = route.createClient(target, { runId });
|
||||
const run: SessionRun = { client, route, runId };
|
||||
const started = await client.execute("health", {}, options);
|
||||
if (!started.ok) {
|
||||
return err(await this.#failedOpen(run, previous, started.error));
|
||||
return err(
|
||||
await this.#failedOpen(
|
||||
client,
|
||||
route.identity.id,
|
||||
previous,
|
||||
started.error,
|
||||
),
|
||||
);
|
||||
}
|
||||
if (isAborted(options.signal)) {
|
||||
return err(
|
||||
await this.#failedOpen(
|
||||
run,
|
||||
client,
|
||||
route.identity.id,
|
||||
previous,
|
||||
new AnalysisCancelledError("open_binary"),
|
||||
),
|
||||
@@ -354,8 +362,10 @@ export class BinarySession
|
||||
}
|
||||
this.#active = {
|
||||
target,
|
||||
client,
|
||||
profile,
|
||||
...run,
|
||||
route,
|
||||
runId,
|
||||
nativeSourceAdmitted: false,
|
||||
};
|
||||
this.#clearRuntimeAvailability();
|
||||
@@ -368,7 +378,14 @@ export class BinarySession
|
||||
const imported = this.importAnalysisSnapshot(options.snapshot);
|
||||
if (!imported.ok) {
|
||||
this.#active = undefined;
|
||||
return err(await this.#failedOpen(run, previous, imported.error));
|
||||
return err(
|
||||
await this.#failedOpen(
|
||||
client,
|
||||
route.identity.id,
|
||||
previous,
|
||||
imported.error,
|
||||
),
|
||||
);
|
||||
}
|
||||
}
|
||||
return ok(target);
|
||||
@@ -488,47 +505,42 @@ export class BinarySession
|
||||
options.progress,
|
||||
options.retainProviderDocuments,
|
||||
)
|
||||
: await this.#retireClient(previous, {
|
||||
...(options.progress === undefined
|
||||
? {}
|
||||
: { progress: options.progress }),
|
||||
...(options.retainProviderDocuments === true
|
||||
? { retainDocument: true }
|
||||
: {}),
|
||||
});
|
||||
: await this.#retireClient(
|
||||
previous.client,
|
||||
previous.route.identity.id,
|
||||
{
|
||||
...(options.progress === undefined
|
||||
? {}
|
||||
: { progress: options.progress }),
|
||||
...(options.retainProviderDocuments === true
|
||||
? { retainDocument: true }
|
||||
: {}),
|
||||
},
|
||||
);
|
||||
if (clearRecords) this.clearSessionRecords();
|
||||
this.#clearRuntimeAvailability();
|
||||
const fileResources = await this.closeWriteResources();
|
||||
const candidates = await this.#providerRouter.closeOwnedResources();
|
||||
let lifecycle: Result<null, AnalysisError>;
|
||||
if (!closed.ok && !fileResources.ok)
|
||||
lifecycle = err(
|
||||
return err(
|
||||
analysisErrorWithCleanupFailure(
|
||||
closed.error,
|
||||
fileResources.error,
|
||||
"close_binary",
|
||||
),
|
||||
);
|
||||
else lifecycle = closed.ok ? fileResources : closed;
|
||||
if (!lifecycle.ok && !candidates.ok)
|
||||
return err(
|
||||
analysisErrorWithCleanupFailure(
|
||||
lifecycle.error,
|
||||
candidates.error,
|
||||
"close_binary",
|
||||
),
|
||||
);
|
||||
return lifecycle.ok ? candidates : lifecycle;
|
||||
return closed.ok ? fileResources : closed;
|
||||
}
|
||||
|
||||
async #retireClient(
|
||||
run: SessionRun,
|
||||
client: AnalysisClient,
|
||||
providerId: string,
|
||||
options: Pick<ExecutionOptions, "progress"> & {
|
||||
readonly retainDocument?: boolean;
|
||||
} = {},
|
||||
): Promise<Result<null, AnalysisError>> {
|
||||
this.#pendingCleanup = {
|
||||
run,
|
||||
client,
|
||||
providerId,
|
||||
retainDocument: options.retainDocument === true,
|
||||
};
|
||||
return this.#retryPendingCleanup(options.progress);
|
||||
@@ -545,8 +557,8 @@ export class BinarySession
|
||||
this.#pendingCleanup = pending;
|
||||
}
|
||||
const closed = await closeAnalysisClient(
|
||||
pending.run.client,
|
||||
pending.run.route.identity.id,
|
||||
pending.client,
|
||||
pending.providerId,
|
||||
{
|
||||
...(progress === undefined ? {} : { progress }),
|
||||
...(pending.retainDocument ? { retainDocument: true } : {}),
|
||||
@@ -557,11 +569,12 @@ export class BinarySession
|
||||
}
|
||||
|
||||
async #failedOpen(
|
||||
run: SessionRun,
|
||||
client: AnalysisClient,
|
||||
providerId: string,
|
||||
previous: SessionBinding | undefined,
|
||||
primary: AnalysisError,
|
||||
): Promise<AnalysisError> {
|
||||
const closed = await this.#retireClient(run);
|
||||
const closed = await this.#retireClient(client, providerId);
|
||||
if (!closed.ok)
|
||||
return analysisErrorWithCleanupFailure(
|
||||
primary,
|
||||
@@ -583,21 +596,18 @@ export class BinarySession
|
||||
|
||||
/** Describe the active binary session. */
|
||||
status(): JsonValue {
|
||||
const run = this.#active ?? this.#pendingCleanup?.run;
|
||||
const client = run?.client;
|
||||
return binarySessionStatus({
|
||||
target: this.#active?.target,
|
||||
route: this.#currentRoute(),
|
||||
router: this.#providerRouter,
|
||||
runtimeUnavailability: this.#runtimeUnavailability,
|
||||
runId: run?.runId,
|
||||
runtimeLineageSnapshots: client?.runtimeLineageSnapshots?.() ?? [],
|
||||
requestActivitySnapshots: client?.requestActivitySnapshots?.() ?? [],
|
||||
providerOperationHealth: client?.operationHealthSnapshot?.() ?? null,
|
||||
cleanupPending:
|
||||
this.#pendingCleanup !== undefined ||
|
||||
this.hasPendingWriteResources ||
|
||||
this.#providerRouter.hasPendingOwnedResources(),
|
||||
runId: this.#active?.runId,
|
||||
runtimeLineageSnapshots:
|
||||
this.#active?.client.runtimeLineageSnapshots?.() ?? [],
|
||||
requestActivitySnapshots:
|
||||
this.#active?.client.requestActivitySnapshots?.() ?? [],
|
||||
providerOperationHealth:
|
||||
this.#active?.client.operationHealthSnapshot?.() ?? null,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -933,19 +943,20 @@ export class BinarySession
|
||||
if (previous === undefined) return ok(null);
|
||||
const runId = randomUUID();
|
||||
const client = previous.route.createClient(previous.target, { runId });
|
||||
const run: SessionRun = { client, route: previous.route, runId };
|
||||
const started = await client.execute("health", {});
|
||||
if (started.ok) {
|
||||
this.#active = {
|
||||
target: previous.target,
|
||||
client,
|
||||
profile: previous.profile,
|
||||
...run,
|
||||
route: previous.route,
|
||||
runId,
|
||||
nativeSourceAdmitted: false,
|
||||
};
|
||||
this.#clearRuntimeAvailability();
|
||||
return ok(null);
|
||||
}
|
||||
const closed = await this.#retireClient(run);
|
||||
const closed = await this.#retireClient(client, previous.route.identity.id);
|
||||
return closed.ok
|
||||
? ok(null)
|
||||
: err(
|
||||
|
||||
@@ -63,11 +63,6 @@ export abstract class BinarySessionRecords {
|
||||
this.#records = records;
|
||||
}
|
||||
|
||||
/** Snapshot staging retained after a failed resource cleanup attempt. */
|
||||
protected get hasPendingWriteResources(): boolean {
|
||||
return this.#writeResources.hasPending;
|
||||
}
|
||||
|
||||
/** Observe changes to the mutable current analysis snapshot resource. */
|
||||
onAnalysisSnapshotChanged(listener: () => void | Promise<void>): () => void {
|
||||
this.#snapshotListeners.add(listener);
|
||||
|
||||
Loaded 100 of 494 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user