Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(process): stabilize native capture and ownership prerequisites

morluto2b2751547662
diff --git a/bridge/native/rea_lldb_tracer.py b/bridge/native/rea_lldb_tracer.py
index 45b2893e8..b99123bf4 100644
--- a/bridge/native/rea_lldb_tracer.py
+++ b/bridge/native/rea_lldb_tracer.py
@@ -323,31 +323,46 @@ def _wanted(spec, symbol):
return symbol.startswith("-[" if method_type == "instance" else "+[")
-def _record(context, thread, index, sequence, location, remaining_bytes):
+def _read_register(frame, name):
+ error = lldb.SBError()
+ value = frame.FindRegister(name)
+ if not value.IsValid():
+ raise RuntimeError("LLDB breakpoint register %s is unavailable" % name)
+ number = value.GetValueAsUnsigned(error)
+ if error.Fail():
+ raise RuntimeError(
+ "LLDB breakpoint register %s could not be read: %s" % (name, error)
+ )
+ return number
+
+
+def _record(context, thread, frame, index, sequence, location, remaining_bytes):
target, process, config = context["target"], context["process"], context["config"]
- frame = thread.GetFrameAtIndex(0)
symbol = location["symbol"] or ""
if not _wanted(config["breakpoints"][index], symbol):
return None
names = ARGUMENT_REGISTERS.get(config["architecture"], [])
+ objc_method = symbol.startswith("-[") or symbol.startswith("+[")
+ values = {
+ name: _read_register(frame, name)
+ for name in names[: max(config["argument_registers"], 2 if objc_method else 0)]
+ }
registers = [
- {"name": name, "value": _hex(frame.FindRegister(name).GetValueAsUnsigned())}
+ {"name": name, "value": _hex(values[name])}
for name in names[: config["argument_registers"]]
]
receiver_class = None
selector = None
- if symbol.startswith("-[") or symbol.startswith("+["):
+ if objc_method:
error = lldb.SBError()
text = process.ReadCStringFromMemory(
- frame.FindRegister(names[1]).GetValueAsUnsigned(),
+ values[names[1]],
MAX_SELECTOR_BYTES,
error,
)
selector = text if error.Success() and text else None
if symbol.startswith("-["):
- receiver_class = _dynamic_class(
- target, frame.FindRegister(names[0]).GetValueAsUnsigned()
- )
+ receiver_class = _dynamic_class(target, values[names[0]])
estimated_base = (
_estimated_json_size(location)
+ _estimated_json_size(receiver_class)
@@ -370,79 +385,100 @@ def _record(context, thread, index, sequence, location, remaining_bytes):
return record
-def _handle_stop(context, events, other_stops):
- """Record breakpoint hits of one stop; return an outcome when tracing must end."""
- process = context["process"]
- for thread in process:
- reason = thread.GetStopReason()
- if reason == lldb.eStopReasonBreakpoint:
- index = context["breakpoint_index"].get(thread.GetStopReasonDataAtIndex(0))
- if index is None:
- continue
- frame = thread.GetFrameAtIndex(0)
- location = _location(frame.GetPCAddress(), context["target"])
- symbol = location["symbol"] or ""
- if not _wanted(context["config"]["breakpoints"][index], symbol):
- continue
- frame_count = max(
- 0,
- min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]),
- )
- event_frame_count = 1 + frame_count
- if not _can_retain_trace(
- context["retained_trace_bytes"],
- context["retained_frames"],
- 0,
- event_frame_count,
- ):
- return "resource-limit"
+# One trace runs in each owned LLDB subprocess. Its callbacks execute at the
+# breakpoint before LLDB resumes, unlike snapshots of later public stop events.
+_TRACE_CONTEXT = None
+
+
+def _handle_breakpoint(context, frame, index):
+ """Read one hit while LLDB's breakpoint callback owns the stopped frame."""
+ if not frame.IsValid() or frame.GetPC() == lldb.LLDB_INVALID_ADDRESS:
+ raise RuntimeError("LLDB breakpoint callback did not supply a readable frame")
+ thread = frame.GetThread()
+ events = context["events"]
+ location = _location(frame.GetPCAddress(), context["target"])
+ symbol = location["symbol"] or ""
+ if not _wanted(context["config"]["breakpoints"][index], symbol):
+ return None
+ frame_count = max(
+ 0,
+ min(thread.GetNumFrames() - 1, context["config"]["backtrace_frames"]),
+ )
+ event_frame_count = 1 + frame_count
+ if not _can_retain_trace(
+ context["retained_trace_bytes"],
+ context["retained_frames"],
+ 0,
+ event_frame_count,
+ ):
+ return "resource-limit"
+ try:
+ remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"]
+ record = _record(
+ context, thread, frame, index, len(events), location, remaining_bytes
+ )
+ except ValueError:
+ return "resource-limit"
+ if record is not None:
+ if not _fits_trace_budget(record, remaining_bytes):
+ return "resource-limit"
+ record_bytes = len(json.dumps(record).encode("utf-8"))
+ if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES:
+ return "resource-limit"
+ for depth in range(1, frame_count + 1):
try:
- remaining_bytes = MAX_TRACE_BYTES - context["retained_trace_bytes"]
- record = _record(
- context, thread, index, len(events), location, remaining_bytes
+ location = _location(
+ thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"]
)
except ValueError:
return "resource-limit"
- if record is not None:
- if not _fits_trace_budget(record, remaining_bytes):
- return "resource-limit"
- record_bytes = len(json.dumps(record).encode("utf-8"))
- if context["retained_trace_bytes"] + record_bytes > MAX_TRACE_BYTES:
- return "resource-limit"
- for depth in range(1, frame_count + 1):
- try:
- location = _location(
- thread.GetFrameAtIndex(depth).GetPCAddress(), context["target"]
- )
- except ValueError:
- return "resource-limit"
- if (
- _estimated_json_size(location) + record_bytes + 1
- > MAX_TRACE_BYTES - context["retained_trace_bytes"]
- ):
- return "resource-limit"
- location_bytes = len(json.dumps(location).encode("utf-8"))
- addition = location_bytes + (1 if record["backtrace"] else 0)
- if (
- context["retained_trace_bytes"]
- + record_bytes
- + addition
- > MAX_TRACE_BYTES
- ):
- return "resource-limit"
- record["backtrace"].append(location)
- record_bytes += addition
- journal = context.get("observation_journal")
- if journal is not None and not journal.append(
- {"kind": "event", "event": record}
- ):
- return "resource-limit"
- events.append(record)
- context["retained_frames"] += event_frame_count
- context["retained_trace_bytes"] += record_bytes
- if len(events) >= context["config"]["max_events"]:
- return "event-limit"
- elif reason in (lldb.eStopReasonSignal, lldb.eStopReasonException):
+ if (
+ _estimated_json_size(location) + record_bytes + 1
+ > MAX_TRACE_BYTES - context["retained_trace_bytes"]
+ ):
+ return "resource-limit"
+ location_bytes = len(json.dumps(location).encode("utf-8"))
+ addition = location_bytes + (1 if record["backtrace"] else 0)
+ if (
+ context["retained_trace_bytes"]
+ + record_bytes
+ + addition
+ > MAX_TRACE_BYTES
+ ):
+ return "resource-limit"
+ record["backtrace"].append(location)
+ record_bytes += addition
+ journal = context.get("observation_journal")
+ if journal is not None and not journal.append(
+ {"kind": "event", "event": record}
+ ):
+ return "resource-limit"
+ events.append(record)
+ context["retained_frames"] += event_frame_count
+ context["retained_trace_bytes"] += record_bytes
+ if len(events) >= context["config"]["max_events"]:
+ return "event-limit"
+ return None
+
+
+def breakpoint_hit(frame, location, internal_dict):
+ """LLDB callback: capture before resuming, and stop on a limit or failure."""
+ context = _TRACE_CONTEXT
+ if context is None or context["outcome"] is not None or context["failure"] is not None:
+ return True
+ try:
+ index = context["breakpoint_index"][location.GetBreakpoint().GetID()]
+ context["outcome"] = _handle_breakpoint(context, frame, index)
+ except Exception as error:
+ context["failure"] = "%s: %s" % (type(error).__name__, error)
+ return True
+ return context["outcome"] is not None
+
+
+def _handle_stop(context, other_stops):
+ """Retain non-breakpoint stop observations; callbacks already capture hits."""
+ for thread in context["process"]:
+ if thread.GetStopReason() in (lldb.eStopReasonSignal, lldb.eStopReasonException):
stop_description = thread.GetStopDescription(256)
journal = context.get("observation_journal")
if journal is not None and not journal.append(
@@ -510,7 +546,17 @@ def _wait_for_exit(listener, process, seconds):
listener.WaitForEvent(1, event)
+def _failed_launch_description(process):
+ if process.GetState() != lldb.eStateExited or process.GetExitStatus() != -1:
+ return None
+ description = process.GetExitDescription()
+ if isinstance(description, str) and description.lower().startswith(("attach failed", "launch failed")):
+ return description
+ return None
+
+
def trace(debugger, config):
+ global _TRACE_CONTEXT
debugger.SetAsync(True)
# Stop at the symbol itself, where argument registers still hold the ABI
# arguments, even when line tables would let LLDB skip the prologue.
@@ -577,6 +623,11 @@ def trace(debugger, config):
stdout.close()
stderr.close()
return {"status": "launch-error", "error": error.GetCString()}
+ launch_failure = _failed_launch_description(process)
+ if launch_failure is not None:
+ stdout.close(expected_exit=True)
+ stderr.close(expected_exit=True)
+ return {"status": "launch-error", "error": launch_failure}
stdout.mark_launched()
stderr.mark_launched()
# Publish the PID before any post-launch file or module inspection. The
@@ -650,6 +701,11 @@ def trace(debugger, config):
"observation_journal": observation_journal,
}
events = []
+ context.update({"events": events, "outcome": None, "failure": None})
+ _TRACE_CONTEXT = context
+ for breakpoints in created:
+ for breakpoint in breakpoints:
+ breakpoint.SetScriptCallbackFunction("rea_lldb_tracer.breakpoint_hit")
other_stops = []
outcome = None
deadline = started + config["duration_ms"] / 1000
@@ -670,7 +726,9 @@ def trace(debugger, config):
if state == lldb.eStateExited:
outcome = "exited"
elif state == lldb.eStateStopped and not lldb.SBProcess.GetRestartedFromEvent(event):
- outcome = _handle_stop(context, events, other_stops)
+ if context["failure"] is not None:
+ raise RuntimeError(context["failure"])
+ outcome = context["outcome"] or _handle_stop(context, other_stops)
if outcome is None:
process.Continue()
pid = process.GetProcessID()
@@ -685,6 +743,12 @@ def trace(debugger, config):
process_exited = process.GetState() == lldb.eStateExited
stdout.close(expected_exit=process_exited)
stderr.close(expected_exit=process_exited)
+ # SBTarget.Launch may succeed before debugserver reports an asynchronous
+ # attach failure as an exited SBProcess. Its -1 status is not a target
+ # exit code; preserve the debugger's concrete launch denial.
+ launch_failure = _failed_launch_description(process)
+ if launch_failure is not None:
+ return {"status": "launch-error", "error": launch_failure}
launch_identity_stable = (
module_path_before is not None
and module_path_after == module_path_before
@@ -733,6 +797,7 @@ def trace(debugger, config):
}
finally:
+ _TRACE_CONTEXT = None
if observation_journal is not None:
try:
observation_journal.handle.close()
diff --git a/bridge/process/ProcessRunTokenReader.swift b/bridge/process/ProcessRunTokenReader.swift
index 1438f8157..21a2726fb 100644
--- a/bridge/process/ProcessRunTokenReader.swift
+++ b/bridge/process/ProcessRunTokenReader.swift
@@ -152,7 +152,14 @@ private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation {
}
bytes = Array(bytes.prefix(size))
do {
- return RunTokenObservation(pid: pid, state: "readable", run_id: try token(in: bytes, pointerSize: pointerSize), reason: nil)
+ let runId = try token(in: bytes, pointerSize: pointerSize)
+ // A complete empty environment is readable for an ordinary image. Apple
+ // platform images can expose the same layout after the kernel withholds
+ // their environment, so they remain explicitly unverified without a token.
+ if runId == nil && isPlatformBinary(pid: pid) {
+ return unavailable(pid: pid, reason: "platform_binary_environment_withheld")
+ }
+ return RunTokenObservation(pid: pid, state: "readable", run_id: runId, reason: nil)
} catch RunTokenReadError.duplicateToken {
return unavailable(pid: pid, reason: "duplicate_run_token")
} catch RunTokenReadError.invalidTokenEncoding {
@@ -259,9 +266,6 @@ func token(in bytes: [UInt8], pointerSize: Int = MemoryLayout<UnsafeRawPointer>.
throw RunTokenReadError.ambiguousEnvironmentBoundary
}
let environmentEntries = trailingEntries[..<appleVectorStart]
- guard !environmentEntries.isEmpty else {
- throw RunTokenReadError.environmentUnavailable
- }
var found: String?
for entry in environmentEntries {
if entry.starts(with: Array("REA_PROCESS_RUN_ID=".utf8)) {
diff --git a/docs/testing.md b/docs/testing.md
index ce5e24bc6..d63f49a12 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -700,13 +700,18 @@ conformance/vtable fixture.
process and helper. These lanes require an interactive macOS desktop. See [native investigation](native-investigation.md)
`npm run verify:native-calls` needs macOS with Command Line Tools (`clang`,
-`lldb`, `codesign`, `nm`) and Developer Mode enabled for unattended debugger
-access. Preflight reports disabled Developer Mode without changing host settings.
+`lldb`, `codesign`, `nm`) and actual debugger access to the owned fixtures.
+The lane reports Developer Mode status without treating it as proof of access
+or denial, and does not change host settings. LLDB and target entitlements
+establish the tested permission boundary.
It compiles `tests/conformance/native/calls.m` and
runs `observe-native-calls` through the CLI and stdio MCP. It checks:
- the receiver class, selector and argument registers of every entry, and that
breakpoint addresses equal `nm`'s symbol addresses;
+- overlapping breakpoint selections retain each selection's hits and share
+ the aggregate event limit; callback capture reads the stopped frame before
+ LLDB resumes, avoiding stale frame metadata from asynchronous stop events;
- captured stdout and an environment override, plus a 2 MiB flood on each
output stream with bounded retained prefixes and exact drained-byte counts;
- the event-limit and duration outcomes, with the process confirmed gone;
@@ -715,10 +720,15 @@ runs `observe-native-calls` through the CLI and stdio MCP. It checks:
### Firmware adapters
+Linux-owned provider launches require a procps-compatible `ps` on REA's `PATH`
+so ownership can be inspected before launching a child. A missing or incompatible
+command fails with an actionable capability error before the launch.
+
`npm run fixtures:firmware` uses existing Python 3 and a host C compiler to make
an ignored gzip/USTAR firmware fixture and independent offset/hash oracle.
`npm run verify:firmware` requires caller-supplied Binwalk 3.1.0, Unblob 26.6.4
-and util-linux prlimit on Linux. The provider also accepts other 3.1.x and
+and util-linux prlimit on Linux, with `7z` on `PATH` for the gzip/USTAR
+fixture's Unblob extractor. The provider also accepts other 3.1.x and
26.6.x builds and reports them as unverified; this lane proves the audited
releases. It verifies CLI/MCP parity, selected ranges,
unknown chunks, depth limits and extracted child digests. The optional
diff --git a/scripts/verify-evm-interface.mjs b/scripts/verify-evm-interface.mjs
index 88c37b649..6a1414fce 100644
--- a/scripts/verify-evm-interface.mjs
+++ b/scripts/verify-evm-interface.mjs
@@ -160,6 +160,24 @@ try {
if (mode === "mcp") assert.deepEqual(value.result, report);
return report;
};
+ const ownershipProbe = join(root.path, "ownership-prerequisite.hex");
+ await writeFile(ownershipProbe, "0x00");
+ const missingInspection = await inspect(
+ "cli",
+ ownershipProbe,
+ "hex",
+ "unsupported_provider",
+ {
+ command: process.execPath,
+ prefix: [],
+ client,
+ environment: { ...environment, PATH: root.path },
+ },
+ );
+ assert.equal(missingInspection.code, "capability_unavailable");
+ assert.match(missingInspection.message, /procps-compatible ps/u);
+ assert.equal(missingInspection.details.operation, "prepare_owned_process");
+ cases++;
for (const [name, optimizer, viaIR] of [
["plain", false, false],
["optimized", true, false],
diff --git a/scripts/verify-native-calls.mjs b/scripts/verify-native-calls.mjs
index a26b16dd8..696b6db52 100644
--- a/scripts/verify-native-calls.mjs
+++ b/scripts/verify-native-calls.mjs
@@ -28,13 +28,6 @@ for (const tool of ["clang", "lldb", "codesign", "nm"])
);
}
const developerMode = await exec("/usr/sbin/DevToolsSecurity", ["-status"]);
-if (
- !/enabled/iu.test(developerMode.stdout) ||
- /disabled/iu.test(developerMode.stdout)
-)
- throw new Error(
- "Native call observation verification requires macOS Developer Mode; DevToolsSecurity reports it disabled.",
- );
const SOURCE = fileURLToPath(
new URL("../tests/conformance/native/calls.m", import.meta.url),
@@ -51,6 +44,8 @@ const INPUT = {
{ kind: "function", name: "rea_call_add" },
],
environment: { REA_CALLS_MARKER: "observed" },
+ // Entry stops and Objective-C runtime reads slow the real target on busy hosts.
+ duration_ms: 30_000,
argument_registers: 4,
backtrace_frames: 1,
};
@@ -59,6 +54,7 @@ const CLI_TIMEOUT_MS = 180_000;
/** Pointer-free facts that two runs of the same scenario must share. */
const stable = (result) =>
result.events.map((event) => ({
+ breakpoint_index: event.breakpoint_index,
symbol: event.symbol,
file_address: event.file_address,
selector: event.selector,
@@ -159,8 +155,7 @@ const checkBounds = async (binary) => {
binary,
[
JSON.stringify({
- breakpoints: [{ kind: "function", name: "nanosleep" }],
- arguments: ["--wait"],
+ breakpoints: [{ kind: "function", name: "rea_call_add" }],
max_events: 2,
duration_ms: 30_000,
}),
@@ -189,8 +184,9 @@ const checkBounds = async (binary) => {
};
const cliFailure = async (binary) => {
+ let output;
try {
- await exec(
+ const completed = await exec(
process.execPath,
[
fileURLToPath(new URL("rea.mjs", import.meta.url)),
@@ -204,10 +200,11 @@ const cliFailure = async (binary) => {
timeout: CLI_TIMEOUT_MS,
},
);
+ output = completed.stdout;
} catch (cause) {
return JSON.parse(cause.stdout);
}
- throw new Error("observe-native-calls unexpectedly succeeded");
+ throw new Error(`observe-native-calls unexpectedly succeeded: ${output}`);
};
/** Hardened runtime blocks the debugger unless get-task-allow is granted. */
@@ -226,6 +223,22 @@ const checkHardenedRuntime = async (directory, binary) => {
const denied = await cliFailure(blocked);
assert.equal(denied.code, "capability_unavailable");
assert.match(denied.details.reason, /^debugger-attach-denied: /u);
+ await withArtifactMcp(blocked, async (client) => {
+ const deniedMcp = await client.callTool(
+ {
+ name: "observe_native_calls",
+ arguments: INPUT,
+ },
+ { timeout: CLI_TIMEOUT_MS },
+ );
+ assert.equal(deniedMcp.isError, true, JSON.stringify(deniedMcp));
+ assert.equal(deniedMcp.structuredContent.error.code, denied.code);
+ assert.match(
+ deniedMcp.structuredContent.error.details.reason,
+ /^debugger-attach-denied: /u,
+ );
+ assert.ok(deniedMcp.structuredContent.error.details.partial_observation);
+ });
const allowed = join(directory, "debuggable");
const entitlements = join(directory, "get-task-allow.plist");
await writeFile(
@@ -267,14 +280,55 @@ try {
"observe_native_calls",
INPUT,
);
+ assert.equal(
+ viaMcp.process.outcome,
+ "exited",
+ JSON.stringify(viaMcp.coverage),
+ );
assert.deepEqual(stable(viaMcp), stable(viaCli));
assert.equal(viaMcp.process.stdout.text, viaCli.process.stdout.text);
+
+ // Two caller selections may resolve to one address. Each must retain its
+ // own hit; consuming only the first stop-reason ID loses the second.
+ const overlapping = {
+ breakpoints: [
+ { kind: "function", name: "rea_call_add" },
+ { kind: "function", name: "rea_call_add", module: basename(binary) },
+ ],
+ duration_ms: 30_000,
+ argument_registers: 2,
+ };
+ const paired = await artifactMcpResult(
+ client,
+ "observe_native_calls",
+ overlapping,
+ );
+ assert.equal(paired.process.outcome, "exited");
+ assert.equal(paired.events.length, 6);
+ for (const index of [0, 1]) {
+ const hits = paired.events.filter(
+ (event) => event.breakpoint_index === index,
+ );
+ assert.deepEqual(
+ hits.map((event) => event.registers[0].value),
+ ["0x0", "0x1", "0x2"],
+ );
+ assert.ok(hits.every((event) => event.symbol === "rea_call_add"));
+ }
+ const capped = await artifactMcpResult(client, "observe_native_calls", {
+ ...overlapping,
+ max_events: 2,
+ });
+ assert.equal(capped.process.outcome, "event-limit");
+ assert.equal(capped.events.length, 2);
+ assert.equal(capped.process.terminated, true);
});
await checkBounds(binary);
await checkHardenedRuntime(directory, binary);
console.log(
JSON.stringify({
ok: true,
+ developer_mode: developerMode.stdout.trim(),
mocked: false,
cli: true,
stdio_mcp: true,
diff --git a/scripts/verify-native-ui.mjs b/scripts/verify-native-ui.mjs
index 8e2f3e05e..174989b14 100644
--- a/scripts/verify-native-ui.mjs
+++ b/scripts/verify-native-ui.mjs
@@ -1,4 +1,5 @@
import { execFile, spawn } from "node:child_process";
+import assert from "node:assert/strict";
import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
@@ -7,6 +8,8 @@ import { promisify } from "node:util";
import { parseBinaryTarget } from "../dist/application/BinaryTargetResolver.js";
import { observeNativeUi } from "../dist/native/NativeUiObservation.js";
import { NATIVE_UI_HELPER_MAX_BUFFER } from "../dist/native/NativeUiOutputBudget.js";
+import { artifactMcpResult, withArtifactMcp } from "./lib/artifact-e2e.mjs";
+import { observeProcessStartIdentity } from "../dist/process/ProcessOwnershipObservation.js";
if (process.platform !== "darwin")
throw new Error(
@@ -14,7 +17,9 @@ if (process.platform !== "darwin")
);
const root = await mkdtemp(join(tmpdir(), "rea-ui-fixture-"));
let child;
+let childExit;
let fixturePid;
+let fixtureIdentity;
let report;
try {
const childRetrievalTest = join(root, "child-retrieval-test");
@@ -89,6 +94,7 @@ try {
["-W", "-n", "-g", "--stdout", coordinates, join(root, "Fixture.app")],
{ stdio: "ignore" },
);
+ childExit = new Promise((resolve) => child.once("exit", resolve));
let scope;
const deadline = Date.now() + 20000;
while (Date.now() < deadline) {
@@ -104,6 +110,12 @@ try {
"Source-owned UI fixture failed to expose one window within 20 seconds",
);
fixturePid = scope.pid;
+ fixtureIdentity = await observeProcessStartIdentity(fixturePid);
+ assert.equal(
+ fixtureIdentity?.state,
+ "readable",
+ "Fixture OS start identity is unavailable",
+ );
const target = await parseBinaryTarget(executable);
if (!target.ok) throw target.error;
const observation = await observeNativeUi(target.value, "observe_native_ui", {
@@ -180,6 +192,43 @@ try {
`Native UI CLI did not preserve the selected scenario: ${JSON.stringify(evidence.error ?? evidence.normalized_result?.steps?.map(({ outcome, reason }) => ({ outcome, reason })))}`,
);
scenarioStatus = "selected-AX-button-action-and-CLI-parity-observed";
+ await withArtifactMcp(executable, async (client) => {
+ const observed = await artifactMcpResult(client, "observe_native_ui", {
+ ...scope,
+ screenshot: false,
+ });
+ if (
+ !observed.initial.nodes.some(
+ (node) =>
+ node.role === "AXButton" &&
+ JSON.stringify(node.path) === JSON.stringify(button.path),
+ )
+ )
+ throw new Error("MCP omitted the selected fixture's actual AX button");
+ const captured = await artifactMcpResult(
+ client,
+ "capture_native_ui_scenario",
+ {
+ ...scope,
+ screenshot: false,
+ steps: [
+ { kind: "click", path: button.path },
+ { kind: "wait", milliseconds: 200 },
+ ],
+ },
+ );
+ if (
+ captured.steps.length !== 2 ||
+ captured.steps.some((step) => step.outcome !== "completed") ||
+ !captured.steps
+ .at(-1)
+ ?.after?.nodes.some(
+ (node) => node.title === "REA fixture incremented",
+ )
+ )
+ throw new Error("MCP did not observe the selected fixture's AX action");
+ });
+ scenarioStatus = "selected-AX-button-action-and-CLI-MCP-parity-observed";
}
const mismatch = await observeNativeUi(
{ ...target.value, sha256: "0".repeat(64) },
@@ -201,17 +250,24 @@ try {
target_owned: true,
};
} finally {
- if (fixturePid !== undefined) {
- try {
- process.kill(fixturePid, "SIGTERM");
- } catch (error) {
- if (error.code !== "ESRCH") throw error;
+ if (fixturePid !== undefined && fixtureIdentity?.state === "readable") {
+ const current = await observeProcessStartIdentity(fixturePid);
+ if (current !== undefined) {
+ assert.ok(
+ current.state === "readable" &&
+ current.identity === fixtureIdentity.identity,
+ "Fixture PID identity changed; refusing to signal another process",
+ );
+ try {
+ process.kill(fixturePid, "SIGTERM");
+ } catch (cause) {
+ if (cause.code !== "ESRCH") throw cause;
+ }
}
}
if (child !== undefined && child.exitCode === null) {
- const exited = new Promise((resolve) => child.once("exit", resolve));
child.kill("SIGTERM");
- await exited;
+ await childExit;
}
await rm(root, { recursive: true, force: true });
}
diff --git a/scripts/verify/firmware/analysis.mjs b/scripts/verify/firmware/analysis.mjs
index f72a78b4a..7f234240b 100644
--- a/scripts/verify/firmware/analysis.mjs
+++ b/scripts/verify/firmware/analysis.mjs
@@ -36,6 +36,14 @@ for (const variable of ["REA_BINWALK_COMMAND", "REA_UNBLOB_COMMAND"]) {
);
await access(path);
}
+try {
+ await exec("7z", ["i"], { timeout: 10_000 });
+} catch (cause) {
+ throw new Error(
+ "verify:firmware prerequisite unavailable: Unblob's gzip/USTAR fixture extraction requires 7z on PATH",
+ { cause },
+ );
+}
const fixtureRoot = resolve(
process.env.REA_FIRMWARE_FIXTURE_ROOT ??
join(repository, "_reference/firmware-integration/generated"),
diff --git a/src/process/ProcessOwnershipObservation.ts b/src/process/ProcessOwnershipObservation.ts
index 723c1b27c..6dc460d97 100644
--- a/src/process/ProcessOwnershipObservation.ts
+++ b/src/process/ProcessOwnershipObservation.ts
@@ -1,4 +1,5 @@
import { readFile } from "node:fs/promises";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
import { launcherIdentityFailure } from "./ProcessOwnershipIdentity.js";
import { descendantsOf, liveProcesses } from "./ProcessOwnershipProcessTree.js";
@@ -300,6 +301,22 @@ export const createSystemProcessOwnershipHost = (
platform,
prepare: async (signal) => {
await darwinTokens?.prepare(signal);
+ if (platform === "linux") {
+ try {
+ const processes = await listProcesses(signal);
+ if (!processes.some(({ pid }) => pid === process.pid))
+ throw new Error("ps did not report REA's current process");
+ } catch (cause: unknown) {
+ if (isExpectedAbort(cause, signal)) throw cause;
+ const reason = `Linux process ownership inspection requires a procps-compatible ps on REA's PATH before launching a child: ${errorMessage(cause)}`;
+ throw new AnalysisCapabilityUnavailableError(
+ "process-ownership",
+ "prepare_owned_process",
+ reason,
+ { cause, userMessage: reason },
+ );
+ }
+ }
},
listProcesses,
async environment(pid) {
diff --git a/tests/boundary/process/darwinProcessRunTokenReader.test.ts b/tests/boundary/process/darwinProcessRunTokenReader.test.ts
index 81fbf9997..8e2977f50 100644
--- a/tests/boundary/process/darwinProcessRunTokenReader.test.ts
+++ b/tests/boundary/process/darwinProcessRunTokenReader.test.ts
@@ -548,7 +548,6 @@ it.skipIf(!onDarwin)(
clearedAppleVectorTokenFailsClosed: true,
callerPfzBeforeTokenRead: true,
emptyLaterArgumentRead: true,
- emptyEnvironmentFailsClosed: true,
emptyArgv0Read: true,
emptyEnvironmentRecordsBeforeTokenFailClosed: true,
duplicateTokenFailsClosed: true,
@@ -677,7 +676,7 @@ it.skipIf(!onDarwin)(
);
it.skipIf(!onDarwin)(
- "reads owned tokens with empty later arguments across executable path padding",
+ "reads owned tokens across executable padding and distinguishes a real empty environment",
async () => {
const root = await mkdtemp(join(tmpdir(), "rea-process-token-padding-"));
const host = createSystemProcessOwnershipHost("darwin");
@@ -699,6 +698,7 @@ it.skipIf(!onDarwin)(
),
);
}
+ children.push(await startNodeChild({}));
const processes = await host.listProcesses();
const entries = children.map(({ pid }) => {
const entry = processes.find((process) => process.pid === pid);
@@ -710,6 +710,7 @@ it.skipIf(!onDarwin)(
expect(children.map(({ pid }) => observations?.get(pid))).toEqual([
{ state: "readable", runId: "synthetic-padding-0" },
{ state: "readable", runId: "synthetic-padding-1" },
+ { state: "readable" },
]);
} finally {
for (const { child } of children) await stopNodeChild(child);
diff --git a/tests/conformance/native/ui.swift b/tests/conformance/native/ui.swift
index 0ee842b49..1d399f00d 100644
--- a/tests/conformance/native/ui.swift
+++ b/tests/conformance/native/ui.swift
@@ -4,6 +4,7 @@ let app = NSApplication.shared
app.setActivationPolicy(.accessory)
let window = NSWindow(contentRect: NSRect(x: 120, y: 120, width: 360, height: 180), styleMask: [.titled, .closable], backing: .buffered, defer: false)
window.title = "REA source-owned UI verification"
+window.animationBehavior = .none
final class FixtureController: NSObject {
@objc func increment(_ sender: NSButton) { sender.title = "REA fixture incremented" }
}
@@ -13,7 +14,8 @@ button.title = "Increment REA fixture"
button.target = controller
button.action = #selector(FixtureController.increment(_:))
window.contentView?.addSubview(button)
-window.orderFront(nil)
+window.makeKeyAndOrderFront(nil)
+app.activate(ignoringOtherApps: true)
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
let record = "{\"pid\":\(ProcessInfo.processInfo.processIdentifier),\"window_id\":\(window.windowNumber)}\n"
FileHandle.standardOutput.write(Data(record.utf8))
diff --git a/tests/fixtures/processRunTokenParserProbe.swift b/tests/fixtures/processRunTokenParserProbe.swift
index b7185d433..a753511f9 100644
--- a/tests/fixtures/processRunTokenParserProbe.swift
+++ b/tests/fixtures/processRunTokenParserProbe.swift
@@ -132,13 +132,6 @@ struct ProcessRunTokenParserProbe {
} catch RunTokenReadError.duplicateToken {
duplicateTokenFailsClosed = true
}
- let emptyEnvironmentFailsClosed: Bool
- do {
- _ = try token(in: fixture(arguments: ["/fixture/executable"], environment: []))
- emptyEnvironmentFailsClosed = false
- } catch RunTokenReadError.environmentUnavailable {
- emptyEnvironmentFailsClosed = true
- }
let missingAppleBoundaryFailsClosed: Bool
do {
_ = try token(in: fixture(
@@ -158,7 +151,6 @@ struct ProcessRunTokenParserProbe {
"alternatePaddingRead": alternatePadding == "alternate-padding-token",
"truncatedArgvFailsClosed": truncatedArgvFailsClosed,
"duplicateTokenFailsClosed": duplicateTokenFailsClosed,
- "emptyEnvironmentFailsClosed": emptyEnvironmentFailsClosed,
"missingAppleBoundaryFailsClosed": missingAppleBoundaryFailsClosed,
"emptyArgv0Read": emptyArgv0Read == "empty-argv0-token",
"finalAssignmentArgumentRead": finalAssignmentArgumentRead == "final-assignment-token",