rea-agents 6.0.0 → 6.2.0

package/bridge/process/ProcessRunTokenReader.swift

@@ -112,6 +112,31 @@ enum RunTokenReadError: Error {
   case ambiguousEnvironmentBoundary
 }
 
+@_silgen_name("csops")
+private func csops(
+  _ pid: Int32,
+  _ ops: UInt32,
+  _ addr: UnsafeMutableRawPointer?,
+  _ size: Int
+) -> Int32
+
+private let csOpsStatus: UInt32 = 0
+private let csPlatformBinary: UInt32 = 0x0400_0000
+
+/**
+ * Whether the target image is an Apple platform binary. Current macOS omits
+ * the environment of platform binaries from KERN_PROCARGS2 for every caller,
+ * so this distinguishes a policy-withheld environment from a process whose
+ * environment is genuinely absent or transiently unreadable.
+ */
+func isPlatformBinary(pid: Int32) -> Bool {
+  var flags: UInt32 = 0
+  let result = withUnsafeMutablePointer(to: &flags) { pointer in
+    csops(pid, csOpsStatus, UnsafeMutableRawPointer(pointer), MemoryLayout<UInt32>.size)
+  }
+  return result == 0 && (flags & csPlatformBinary) != 0
+}
+
 private func readRunToken(pid: Int32, pointerSize: Int) -> RunTokenObservation {
   var mib = [CTL_KERN, KERN_PROCARGS2, Int32(pid)]
   var size = 0
@@ -127,13 +152,25 @@ 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 {
     return unavailable(pid: pid, reason: "invalid_run_token_encoding")
   } catch RunTokenReadError.environmentUnavailable {
-    return unavailable(pid: pid, reason: "environment_unavailable")
+    return unavailable(
+      pid: pid,
+      reason: isPlatformBinary(pid: pid)
+        ? "platform_binary_environment_withheld"
+        : "environment_unavailable"
+    )
   } catch RunTokenReadError.appleVectorUnavailable {
     return unavailable(pid: pid, reason: "apple_vector_unavailable")
   } catch RunTokenReadError.ambiguousEnvironmentBoundary {
@@ -229,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)) {

package/bridge/pwntools/recorded_crash_impl.py

@@ -43,6 +43,10 @@ def inspect_core(path, cache):
         raise CoreFailure("unsupported-target", "Initial recorded-core profile requires ELF64 little-endian.")
     if len(content) < 64:
         raise CoreFailure("format", "Selected ELF64 core header is truncated.")
+    if content[6] != 1:
+        raise CoreFailure("format", "ELF identification version is not EV_CURRENT.")
+    if int.from_bytes(content[20:24], "little") != 1:
+        raise CoreFailure("format", "ELF header version is not EV_CURRENT.")
     # Linux commonly emits ELFOSABI_NONE (0), also accepted as GNU/Linux (3).
     # Other declared OSABIs must never select Linux note ctypes.
     if content[7] not in (0, 3) or content[8] != 0:

package/dist/android/JadxConfiguration.js

@@ -1,44 +1,210 @@
-import { access, realpath, stat } from "node:fs/promises";
 import { constants } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { access, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { systemWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";
+import { execFileOutput, execFileOutputFailure, } from "../process/ExecFileOutput.js";
 import { JADX_JAR_CONFIGURATION_REMEDIATION } from "./JadxRelease.js";
-/** Admit explicit local tooling without installing or changing host configuration. */
-export const resolveJadxConfiguration = async (environment, operation) => {
-    const unavailable = (reason) => new AnalysisCapabilityUnavailableError("jadx", operation, reason);
-    if (process.platform !== "linux" && process.platform !== "darwin")
-        throw unavailable(`Android JADX subprocess ownership is unsupported on ${process.platform}; use Linux or macOS. The metadata bridge has real-provider verification on macOS arm64.`);
+const JAVA_MODULE_LISTING_TIMEOUT_MS = 10_000;
+const JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES = 1024 * 1024;
+// Bound ZIP metadata allocation during discovery. The audited 0.7.1 JAR's
+// central directory occupies 2,294,350 bytes; class bodies are not read here.
+const JAR_METADATA_READ_MAX_BYTES = 8 * 1024 * 1024;
+class JadxConfigurationFailure extends Error {
+    code;
+    diagnostics;
+    constructor(code, message, diagnostics, options) {
+        super(message, options);
+        this.code = code;
+        this.diagnostics = diagnostics;
+    }
+}
+/** Inspect the same JAR and Java prerequisites that gate actual execution. */
+export const inspectJadxAvailability = async (environment, signal) => {
+    try {
+        const configuration = await readJadxConfiguration(environment, signal);
+        return {
+            status: "available",
+            code: null,
+            reason: null,
+            diagnostics: {
+                configured: true,
+                java_executable: configuration.java,
+                jdk_compiler: true,
+                jar_path: configuration.jar,
+            },
+        };
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw cause;
+        if (cause instanceof JadxConfigurationFailure)
+            return {
+                status: "unavailable",
+                code: cause.code,
+                reason: cause.message,
+                diagnostics: cause.diagnostics,
+            };
+        throw cause;
+    }
+};
+/** Resolve caller-selected tools and preserve the same prerequisite diagnostics. */
+export const resolveJadxConfiguration = async (environment, operation, signal) => {
+    try {
+        return await readJadxConfiguration(environment, signal);
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw cause;
+        if (!(cause instanceof JadxConfigurationFailure))
+            throw cause;
+        const output = cause.diagnostics;
+        throw new AnalysisCapabilityUnavailableError("jadx", operation, cause.message, {
+            cause,
+            userMessage: cause.message,
+            ...(typeof output.stdout === "string" &&
+                typeof output.stderr === "string"
+                ? {
+                    capturedOutput: {
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        truncated: output.output_truncated === true,
+                    },
+                }
+                : {}),
+        });
+    }
+};
+const readJadxConfiguration = async (environment, signal) => {
+    requireSupportedHost();
+    const jar = await resolveJar(environment);
+    const java = await resolveJava(environment, signal);
+    await requireJavaHomeExecutable(environment.JAVA_HOME, java);
+    const jvmArguments = resolveJvmArguments(environment);
+    await inspectJavaRuntime(java, environment, signal);
+    await requireEngineArchive(jar, signal);
+    return { jar, java, jvmArguments };
+};
+const requireEngineArchive = async (jar, signal) => {
+    // These classes are consumed directly by ReaJadxBridge.java. This checks the
+    // classpath inventory without loading engine code or starting a JADX session.
+    const missing = new Set([
+        "com/atxx/jhmcp/JadxSession.class",
+        "com/atxx/jhmcp/SessionHolder.class",
+        "jadx/api/JadxDecompiler.class",
+        "com/google/gson/Gson.class",
+        "io/modelcontextprotocol/kotlin/sdk/server/Server.class",
+    ]);
+    const reader = new ZipArtifactReader(jar, "zip", JAR_METADATA_READ_MAX_BYTES);
+    try {
+        for await (const entry of reader.entries(signal)) {
+            if (entry.kind === "file" && !entry.encrypted)
+                missing.delete(entry.path);
+            if (missing.size === 0)
+                return;
+        }
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw cause;
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        throw configurationFailure("version_unresolved", `Cannot inspect REA_JADX_MCP_JAR ${jar} as a Java archive: ${reason}. ${JADX_JAR_CONFIGURATION_REMEDIATION}`, {
+            jar_path: jar,
+            phase: "jar-inspection",
+            archive_error: reason,
+            maximum_metadata_read_bytes: JAR_METADATA_READ_MAX_BYTES,
+        }, cause);
+    }
+    finally {
+        await reader.close();
+    }
+    throw configurationFailure("unsupported_version", `REA_JADX_MCP_JAR ${jar} does not contain the required metadata bridge classes: ${[...missing].join(", ")}. ${JADX_JAR_CONFIGURATION_REMEDIATION}`, { jar_path: jar, phase: "jar-inspection", missing_classes: [...missing] });
+};
+const requireSupportedHost = () => {
+    if (process.platform === "linux" || process.platform === "darwin")
+        return;
+    if (process.platform === "win32" && process.arch === "x64") {
+        const loaded = systemWindowsNativeAuthority();
+        if (loaded.available && loaded.authority.inspection.protocolStdin === true)
+            return;
+        throw configurationFailure("runtime_missing", loaded.available
+            ? "The bundled Windows native artifact lacks owned protocol stdin; use a matching current Windows x64 REA package."
+            : loaded.reason, {
+            platform: process.platform,
+            architecture: process.arch,
+            phase: "process-ownership",
+            owned_protocol_stdin: false,
+        });
+    }
+    throw configurationFailure("unsupported_host", `Android JADX subprocess ownership is unsupported on ${process.platform}/${process.arch}; use Linux, macOS, or Windows x64 with its bundled native controls.`, { platform: process.platform });
+};
+const resolveJar = async (environment) => {
     const jar = environment.REA_JADX_MCP_JAR;
-    if (environment.JAVA_HOME !== undefined && !isAbsolute(environment.JAVA_HOME))
-        throw unavailable("JAVA_HOME must select an existing JDK by absolute path; omit it to use java on PATH.");
     if (jar === undefined || !isAbsolute(jar))
-        throw unavailable(JADX_JAR_CONFIGURATION_REMEDIATION);
-    const java = environment.JAVA_HOME === undefined
-        ? "java"
-        : join(environment.JAVA_HOME, "bin", "java");
+        throw configurationFailure("not_configured", JADX_JAR_CONFIGURATION_REMEDIATION, { jar_configured: false });
     try {
         await access(jar, constants.R_OK);
         if (!(await stat(jar)).isFile())
-            throw unavailable(`REA_JADX_MCP_JAR is not a regular file: ${jar}`);
+            throw configurationFailure("executable_missing", `REA_JADX_MCP_JAR is not a regular file: ${jar}`, { jar_path: jar });
+        return await realpath(jar);
     }
     catch (cause) {
-        if (cause instanceof AnalysisCapabilityUnavailableError)
+        if (cause instanceof JadxConfigurationFailure)
             throw cause;
-        throw unavailable(`Cannot read REA_JADX_MCP_JAR ${jar}: ${cause instanceof Error ? cause.message : String(cause)}`);
+        throw configurationFailure("executable_missing", `Cannot read REA_JADX_MCP_JAR ${jar}: ${cause instanceof Error ? cause.message : String(cause)}`, { jar_path: jar }, cause);
     }
-    if (environment.JAVA_HOME !== undefined) {
-        try {
-            await access(java, constants.R_OK | constants.X_OK);
-            if (!(await stat(java)).isFile())
-                throw unavailable(`JAVA_HOME java is not a regular file: ${java}`);
-        }
-        catch (cause) {
-            if (cause instanceof AnalysisCapabilityUnavailableError)
-                throw cause;
-            throw unavailable(`Cannot execute JAVA_HOME java ${java}: ${cause instanceof Error ? cause.message : String(cause)}`);
+};
+const resolveJava = async (environment, signal) => {
+    const executable = process.platform === "win32" ? "java.exe" : "java";
+    if (environment.JAVA_HOME === undefined) {
+        if (process.platform !== "win32")
+            return executable;
+        const path = Object.entries(environment).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+        for (const directory of [process.cwd(), ...path.split(delimiter)]) {
+            signal?.throwIfAborted();
+            // Windows PATH commonly quotes individual entries containing spaces.
+            const selected = directory.startsWith('"') && directory.endsWith('"')
+                ? directory.slice(1, -1)
+                : directory;
+            const candidate = resolve(selected, executable);
+            try {
+                await access(candidate, constants.R_OK | constants.X_OK);
+                if ((await stat(candidate)).isFile())
+                    return await realpath(candidate);
+            }
+            catch (cause) {
+                if (typeof cause === "object" &&
+                    cause !== null &&
+                    "code" in cause &&
+                    (cause.code === "ENOENT" || cause.code === "ENOTDIR"))
+                    continue;
+                throw configurationFailure("runtime_missing", `Cannot inspect selected Java executable ${candidate}: ${errorText(cause)}`, { java_executable: candidate }, cause);
+            }
         }
+        throw configurationFailure("runtime_missing", "Cannot find java.exe on the selected Windows PATH. Select a full JDK with JAVA_HOME or PATH, then verify it with java --list-modules. REA does not install Java.", { java_executable: executable });
     }
-    const jvmArguments = [];
+    if (isAbsolute(environment.JAVA_HOME))
+        return join(environment.JAVA_HOME, "bin", executable);
+    throw configurationFailure("open_options_invalid", "JAVA_HOME must select an existing JDK by absolute path; omit it to use java on PATH.", { java_home: environment.JAVA_HOME });
+};
+const requireJavaHomeExecutable = async (javaHome, java) => {
+    if (javaHome === undefined)
+        return;
+    try {
+        await access(java, constants.R_OK | constants.X_OK);
+        if ((await stat(java)).isFile())
+            return;
+        throw configurationFailure("runtime_missing", `JAVA_HOME java is not a regular file: ${java}`, { java_executable: java });
+    }
+    catch (cause) {
+        if (cause instanceof JadxConfigurationFailure)
+            throw cause;
+        throw configurationFailure("runtime_missing", `Cannot execute JAVA_HOME java ${java}: ${cause instanceof Error ? cause.message : String(cause)}`, { java_executable: java }, cause);
+    }
+};
+const resolveJvmArguments = (environment) => {
+    const result = [];
     for (const [name, prefix, suffix] of [
         ["REA_JADX_HEAP_MIB", "-Xmx", "m"],
         ["REA_JADX_ACTIVE_PROCESSOR_COUNT", "-XX:ActiveProcessorCount=", ""],
@@ -47,11 +213,88 @@ export const resolveJadxConfiguration = async (environment, operation) => {
         if (value === undefined)
             continue;
         if (!/^[1-9]\d*$/u.test(value) || !Number.isSafeInteger(Number(value)))
-            throw unavailable(`${name} must be a positive safe integer; received ${value}.`);
+            throw configurationFailure("open_options_invalid", `${name} must be a positive safe integer; received ${value}.`, { setting: name, value });
         if (name === "REA_JADX_ACTIVE_PROCESSOR_COUNT" &&
             Number(value) > 2_147_483_647)
-            throw unavailable(`${name} exceeds the JVM's signed 32-bit processor-count range.`);
-        jvmArguments.push(`${prefix}${value}${suffix}`);
+            throw configurationFailure("open_options_invalid", `${name} exceeds the JVM's signed 32-bit processor-count range.`, { setting: name, value });
+        result.push(`${prefix}${value}${suffix}`);
+    }
+    return result;
+};
+const inspectJavaRuntime = async (java, environment, signal) => {
+    let stdout;
+    let stderr;
+    try {
+        ({ stdout, stderr } = await execFileOutput(java, ["--list-modules"], {
+            env: { ...environment },
+            timeout: JAVA_MODULE_LISTING_TIMEOUT_MS,
+            maxBuffer: JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES,
+            ...(signal === undefined ? {} : { signal }),
+        }));
+    }
+    catch (cause) {
+        if (signal?.aborted === true)
+            throw cause;
+        const output = execFileOutputFailure(cause);
+        if (output === undefined)
+            throw cause;
+        const diagnostics = {
+            java_executable: java,
+            phase: "module-inspection",
+            exit_code: typeof output.code === "number" ? output.code : null,
+            process_error_code: typeof output.code === "string" ? output.code : null,
+            signal: output.signal,
+            killed: output.killed,
+            stdout: output.stdout,
+            stderr: output.stderr,
+            output_truncated: output.outputTruncated,
+        };
+        if (output.outputTruncated)
+            throw configurationFailure("version_unresolved", `The selected Java launcher ${java} exceeded the ${JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES / (1024 * 1024)} MiB output budget while listing modules. REA retained partial output but could not establish compiler or version availability. Inspect the selected launcher for verbose or unbounded output; ` +
+                "java --list-modules should return a concise module listing.", {
+                ...diagnostics,
+                failure: "output_limit",
+                output_limit_bytes: JAVA_MODULE_LISTING_MAX_OUTPUT_BYTES,
+            }, cause);
+        if (output.killed)
+            throw configurationFailure("version_unresolved", `The selected Java launcher ${java} was terminated or did not finish the module-listing probe within ${JAVA_MODULE_LISTING_TIMEOUT_MS / 1000} seconds. Inspect the launcher and its startup responsiveness, then verify it returns compiler and version modules with java --list-modules.`, {
+                ...diagnostics,
+                failure: "probe_terminated",
+                deadline_ms: JAVA_MODULE_LISTING_TIMEOUT_MS,
+            }, cause);
+        throw configurationFailure("runtime_missing", `Cannot inspect selected Java runtime ${java}: ${output.stderr.trim() || errorText(cause)}. Select a full JDK including jdk.compiler via JAVA_HOME or PATH; verify it with java --list-modules.`, diagnostics, cause);
     }
-    return { jar: await realpath(jar), java, jvmArguments };
+    const compiler = /^jdk\.compiler(?:@|$)/mu.test(stdout);
+    if (!compiler)
+        throw configurationFailure("runtime_missing", `Selected Java runtime ${java} does not provide jdk.compiler. Select a full JDK including jdk.compiler via JAVA_HOME or PATH; verify it with java --list-modules. A JRE cannot compile REA's source bridge.`, {
+            java_executable: java,
+            phase: "module-inspection",
+            jdk_compiler: false,
+            stdout,
+            stderr,
+            output_truncated: false,
+        });
+    const major = /^java\.base@(\d+)(?:[.+_-]|$)/mu.exec(stdout)?.[1];
+    if (major === undefined)
+        throw configurationFailure("version_unresolved", `The selected Java launcher ${java} did not report a parseable java.base version in its module listing. Inspect the launcher output and verify it with java --list-modules.`, {
+            java_executable: java,
+            phase: "module-inspection",
+            jdk_compiler: true,
+            java_major: null,
+            stdout,
+            stderr,
+            output_truncated: false,
+        });
+    if (Number(major) < 17)
+        throw configurationFailure("unsupported_version", `Selected Java runtime ${java} must be JDK 17 or newer and include jdk.compiler; verify it with java --list-modules.`, {
+            java_executable: java,
+            phase: "module-inspection",
+            jdk_compiler: true,
+            java_major: major ?? null,
+            stdout,
+            stderr,
+            output_truncated: false,
+        });
 };
+const configurationFailure = (code, message, diagnostics, cause) => new JadxConfigurationFailure(code, message, diagnostics, cause === undefined ? undefined : { cause });
+const errorText = (cause) => cause instanceof Error ? cause.message : String(cause);

package/dist/android/JadxMcpTransport.js

@@ -1,5 +1,6 @@
 import { deserializeMessage, serializeMessage, } from "@modelcontextprotocol/client";
 import { randomUUID } from "node:crypto";
+import { finished } from "node:stream/promises";
 import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
 import { cleanupOwnedProcessGroup } from "../process/ProcessOwnership.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
@@ -71,13 +72,20 @@ export class JadxMcpTransport {
     }
     /** Verifies owned process exit before declaring the transport closed. */
     close() {
-        this.#closePromise ??= this.#stop();
+        this.#closePromise ??= this.#stop().catch((cause) => {
+            this.#closePromise = undefined;
+            throw cause;
+        });
         return this.#closePromise;
     }
     /** Captured provider stderr without persisting inherited environment values. */
     diagnostics() {
         return this.#supervisor?.snapshot().stderr.text ?? "";
     }
+    /** Whether the retained startup/operation diagnostics lost bytes. */
+    diagnosticsTruncated() {
+        return this.#supervisor?.snapshot().diagnosticTruncated ?? false;
+    }
     /** Preserve the failed protocol/resource constraint after the SDK closes requests. */
     failureReason() {
         return this.#failure;
@@ -98,8 +106,16 @@ export class JadxMcpTransport {
         process?.stderr?.off("data", this.#countStderr);
         process?.off("error", this.#error);
         process?.off("exit", this.#exit);
-        process?.stdin?.off("error", this.#error);
+        const input = process?.stdin;
+        // A job termination can complete an in-flight pipe write asynchronously.
+        // Observe its errors until the owned Writable has finished closing.
+        const inputClosed = input === undefined || input === null
+            ? undefined
+            : finished(input, { readable: false, cleanup: true }).catch(() => undefined);
         const stopped = await this.#supervisor?.stop();
+        input?.destroy();
+        await inputClosed;
+        input?.off("error", this.#error);
         this.onclose?.();
         if (stopped?.status === "incomplete")
             throw new ProviderCleanupError("jadx", [this.runId], {

package/dist/android/JadxProtocol.js

@@ -2,6 +2,12 @@ import { z } from "zod";
 import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const count = z.number().int().nonnegative();
+/** Selector failures authored by REA's bridge, separate from arbitrary engine errors. */
+export const jadxInputFailureSchema = z.strictObject({
+    kind: z.literal("invalid-input"),
+    field: z.enum(["class_name", "method_name", "overload_index"]),
+    message: z.string().min(1),
+});
 /** Values observed inside the exact JVM producing the analysis. */
 export const jadxRuntimeSchema = z.object({
     engine_reported_version: z.string().min(1),