Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
feat(android): make the JADX operation deadline configurable (#4466)
Paritosh Lahref4337864633c
diff --git a/.agents/skills/reverse-engineer-anything/references/android-applications.md b/.agents/skills/reverse-engineer-anything/references/android-applications.mdindex 896f15f85..912a42f5b 100644--- a/.agents/skills/reverse-engineer-anything/references/android-applications.md+++ b/.agents/skills/reverse-engineer-anything/references/android-applications.md@@ -24,7 +24,9 @@ matching bundled native controls and uses an owned Job Object with bidirectionalstdio. A full JDK, including `jdk.compiler`, is required on every host; Windows`JAVA_HOME` selects `bin\java.exe`. Consult the Android guide for actual hostverification coverage. Calls use one worker and provider deadlines; optional-`REA_JADX_HEAP_MIB` selects the JVM heap. The APK is never launched,+`REA_JADX_HEAP_MIB` selects the JVM heap and `REA_JADX_OPERATION_TIMEOUT_MS`+the per-operation deadline (default 120000 ms; the MCP client's tool timeout+must also allow it). The APK is never launched,and no emulator is required.Manifest entries and decompiled text are static observations, not execution ordiff --git a/docs/android-analysis.md b/docs/android-analysis.mdindex 1bad04353..7d81a2b90 100644--- a/docs/android-analysis.md+++ b/docs/android-analysis.md@@ -300,8 +300,25 @@ down to MiB and retains exact bytes, Java version and visible processors in itsraw runtime response. The observed allocatable heap can differ from configured`-Xmx`, especially with Serial GC. Heap is not a total RSS cap: the JVM alsouses native memory. Independent REA instances have independent queues. Whole-operations have a **120-second** execution deadline after reaching the queue's-front; upstream decompilation is limited to **90 seconds**.+operations have a **120-second** execution deadline by default, starting after+they reach the queue's front. For a known slow cold load, such as a large+multidex APK, select another finite deadline:++```sh+export REA_JADX_OPERATION_TIMEOUT_MS=600000+```++The value must be a decimal millisecond count from 1 to 2147483647; anything+else is refused before Java starts. The same deadline bounds each upstream+call, a timeout reports the selected value, and a passing JADX configuration+check in `rea doctor` reports the effective `operation_timeout_ms`. Explicit+cancellation still ends the operation immediately, and partial observations+and owned-process cleanup are unchanged. Raising the deadline does not extend+the bridge's 30-second startup handshake or the upstream **90-second**+decompilation limit. MCP clients enforce their own tool-call timeouts, and+setup's derived [client tool timeout](client-configuration.md) does not include+this setting, so also raise the client timeout when selecting a longer+deadline.Decoded manifest and method text have a **1 MiB** upstream byte budget and reporttruncation. Class-name pages use indexed slices of up to 4,096 names without changing thediff --git a/docs/client-configuration.md b/docs/client-configuration.mdindex add6ac002..9cdc4e62d 100644--- a/docs/client-configuration.md+++ b/docs/client-configuration.md@@ -151,7 +151,10 @@ An explicit `REA_JEB_MCP_TIMEOUT_MS` request budget also contributes to thatmaximum. For `ida` or `auto` selection, a valid IDA registration's parsed`timeoutMs` also contributes to that maximum; its default is 300000 ms.Setup forwards these explicitly selected REA deadlines and the input schema-profile into the registration; unrelated process values are omitted.+profile into the registration; unrelated process values are omitted. An+explicit `REA_JADX_OPERATION_TIMEOUT_MS` is forwarded with the JADX+registration but does not contribute to the derived tool timeout; raise+`toolTimeoutMs` to cover a longer selected JADX deadline.This headroom is a practical default, not a guarantee for every analysisduration. Setup preserves positive timeout values already in the `rea` entry.You can edit `startupTimeoutMs` and `toolTimeoutMs` there; doctor keeps positive@@ -245,6 +248,9 @@ values in the REA entry, and doctor reports a non-blocking advisory when a tooltimeout is shorter than the known provider allowance. An explicitly selectedJEB request budget also contributes to the allowance. A configured IDAregistration's parsed `timeoutMs` contributes for `ida` or `auto` selection.+An explicit `REA_JADX_OPERATION_TIMEOUT_MS` is forwarded with the JADX+registration but does not contribute; raise `tool_timeout_sec` to cover a+longer selected JADX deadline.These values are client-side deadlines, so increase them in `~/.codex/config.toml` if aworkload needs more time. Devin honors `XDG_CONFIG_HOME` for its`devin/mcp_config.json` on non-Windows systems.diff --git a/src/android/JadxConfiguration.ts b/src/android/JadxConfiguration.tsindex e07e2c211..fe517cb70 100644--- a/src/android/JadxConfiguration.ts+++ b/src/android/JadxConfiguration.ts@@ -3,9 +3,11 @@ import { access, realpath, stat } from "node:fs/promises";import { delimiter, isAbsolute, join, resolve } from "node:path";import { inspectWindowsNativeReadiness } from "../process/WindowsAuthority.js";import { systemWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js";+import { providerStartupTimeoutSchema } from "../config/providerStartupTimeout.js";import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";import type { AndroidOperation } from "../domain/android/androidAnalysis.js";import type { JsonValue } from "../domain/jsonValue.js";+import { err, ok, type Result } from "../domain/result.js";import type { ProviderAvailability } from "../application/AnalysisProvider.js";import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";import {@@ -14,10 +16,12 @@ import {} from "../process/ExecFileOutput.js";import type { DoctorProviderCheck } from "../application/Doctor.js";import {+ DEFAULT_JADX_OPERATION_TIMEOUT_MS,JADX_JAR_CONFIGURATION_REMEDIATION,JADX_JAVA_PROBE_REMEDIATION,JADX_JAVA_RUNTIME_REMEDIATION,JADX_JVM_OPTIONS_REMEDIATION,+ JADX_OPERATION_TIMEOUT_REMEDIATION,JADX_UNSUPPORTED_HOST_REMEDIATION,JADX_WINDOWS_NATIVE_REMEDIATION,} from "./JadxRelease.js";@@ -57,6 +61,7 @@ export type JadxFailureKind =| "java_runtime"| "java_home"| "jvm_options"+ | "operation_timeout"| "jar"| "java_probe"| "unsupported_host";@@ -68,6 +73,7 @@ export const JADX_FAILURE_KINDS: readonly JadxFailureKind[] = ["java_runtime","java_home","jvm_options",+ "operation_timeout","jar","java_probe","unsupported_host",@@ -114,6 +120,11 @@ export const projectJadxFailureOutcome = (remediation: JADX_JVM_OPTIONS_REMEDIATION,classification: drift,};+ case "operation_timeout":+ return {+ remediation: JADX_OPERATION_TIMEOUT_REMEDIATION,+ classification: drift,+ };case "jar":return {remediation: JADX_JAR_CONFIGURATION_REMEDIATION,@@ -155,6 +166,7 @@ export const inspectJadxAvailability = async (signal?: AbortSignal,): Promise<ProviderAvailability> => {try {+ const operationTimeoutMs = readOperationTimeout(environment);const configuration = await readJadxConfigurationInputs(environment,signal,@@ -169,6 +181,7 @@ export const inspectJadxAvailability = async (java_executable: configuration.java,jdk_compiler: true,jar_path: configuration.jar,+ operation_timeout_ms: operationTimeoutMs,},};} catch (cause) {@@ -184,6 +197,22 @@ export const inspectJadxAvailability = async (}};+/**+ * Resolve the whole-operation deadline before any admission work starts, so+ * one value bounds the provider operation and each upstream call.+ */+export const resolveJadxOperationTimeout = (+ environment: Readonly<Record<string, string | undefined>>,+ operation: AndroidOperation,+): Result<number, AnalysisCapabilityUnavailableError> => {+ try {+ return ok(readOperationTimeout(environment));+ } catch (cause) {+ if (!(cause instanceof JadxConfigurationFailure)) throw cause;+ return err(projectConfigurationFailure(operation, cause));+ }+};+/** Resolve caller-selected paths and JVM options without probing their contents. */export const resolveJadxConfigurationInputs = async (environment: Readonly<Record<string, string | undefined>>,@@ -508,6 +537,21 @@ const resolveJvmArguments = (return result;};+const readOperationTimeout = (+ environment: Readonly<Record<string, string | undefined>>,+): number => {+ const value = environment.REA_JADX_OPERATION_TIMEOUT_MS;+ if (value === undefined) return DEFAULT_JADX_OPERATION_TIMEOUT_MS;+ const parsed = providerStartupTimeoutSchema.safeParse(value);+ if (parsed.success) return parsed.data;+ throw configurationFailure(+ "open_options_invalid",+ `REA_JADX_OPERATION_TIMEOUT_MS must be a decimal millisecond count from 1 to 2147483647; received ${value}.`,+ { setting: "REA_JADX_OPERATION_TIMEOUT_MS", value },+ "operation_timeout",+ );+};+const inspectJavaRuntime = async (java: string,environment: Readonly<Record<string, string | undefined>>,diff --git a/src/android/JadxDoctor.ts b/src/android/JadxDoctor.tsindex b357d1e85..7a4ed54c0 100644--- a/src/android/JadxDoctor.ts+++ b/src/android/JadxDoctor.ts@@ -49,6 +49,10 @@ export const inspectJadxProvider = async ("REA_JADX_ACTIVE_PROCESSOR_COUNT",environment.REA_JADX_ACTIVE_PROCESSOR_COUNT,),+ ...optionalEntry(+ "REA_JADX_OPERATION_TIMEOUT_MS",+ environment.REA_JADX_OPERATION_TIMEOUT_MS,+ ),},checks: [configurationCheck(configured, availability, jarPath)],};@@ -70,6 +74,7 @@ const configurationCheck = (): DoctorProviderCheck => {const code = availability.status === "unavailable" ? availability.code : null;if (availability.status === "available" && jarPath !== undefined) {+ const operationTimeout = availability.diagnostics["operation_timeout_ms"];return {name: "configuration",ok: true,@@ -77,6 +82,9 @@ const configurationCheck = (detail: `JADX MCP bridge JAR validated at ${jarPath}; its path is recorded for agent registrations.`,remediation: null,classification: "config_drift",+ ...(typeof operationTimeout === "number"+ ? { details: { operation_timeout_ms: operationTimeout } }+ : {}),};}// The failure kind is tagged at the configuration boundary; project itsdiff --git a/src/android/JadxProvider.ts b/src/android/JadxProvider.tsindex 39b13871b..8fb456c64 100644--- a/src/android/JadxProvider.ts+++ b/src/android/JadxProvider.ts@@ -34,13 +34,13 @@ import { RegularFileCleanupFailure } from "../filesystem/OwnedRegularFile.js";import {inspectJadxAvailability,resolveJadxConfigurationInputs,+ resolveJadxOperationTimeout,validateJadxConfiguration,} from "./JadxConfiguration.js";import type { JadxLauncher } from "./JadxMcpTransport.js";import { JadxSession } from "./JadxSession.js";-const OPERATION_TIMEOUT_MS = 120_000;const BRIDGE_SOURCE = fileURLToPath(new URL("../../bridge/android/ReaJadxBridge.java", import.meta.url),);@@ -65,10 +65,11 @@ const executionError = (context: {cause: unknown;request: AndroidRequest;timeout: AbortSignal;+ timeoutMs: number;signal: AbortSignal | undefined;session: JadxSession | undefined;}): AnalysisError => {- const { cause, request, timeout, signal, session } = context;+ const { cause, request, timeout, timeoutMs, signal, session } = context;if (cause instanceof RegularFileCleanupFailure) {const primaryCause =cause.outcome.kind === "failed"@@ -86,7 +87,7 @@ const executionError = (context: {: timeout.aborted? new AnalysisTimeoutError(request.operation,- OPERATION_TIMEOUT_MS,+ timeoutMs,primaryOptions,): primaryCause instanceof AnalysisError@@ -114,7 +115,7 @@ const executionError = (context: {if (signal?.aborted === true)return new AnalysisCancelledError(request.operation, { cause });if (timeout.aborted)- return new AnalysisTimeoutError(request.operation, OPERATION_TIMEOUT_MS);+ return new AnalysisTimeoutError(request.operation, timeoutMs);if (cause instanceof AnalysisError) return cause;const protocolFailure = session?.transport.failureReason();if (protocolFailure !== undefined && protocolFailure !== null)@@ -440,7 +441,14 @@ export class JadxProvider implements AndroidAnalysisPort {request: AndroidRequest,options?: ExecutionOptions,): Promise<Outcome> {- const timeout = AbortSignal.timeout(OPERATION_TIMEOUT_MS);+ // The deadline is fixed per provider environment; an unusable value is+ // refused before any file handle, workspace, or engine is acquired.+ const timeoutMs = resolveJadxOperationTimeout(+ this.environment,+ request.operation,+ );+ if (!timeoutMs.ok) return timeoutMs;+ const timeout = AbortSignal.timeout(timeoutMs.value);const signal =options?.signal === undefined? timeout@@ -596,6 +604,7 @@ export class JadxProvider implements AndroidAnalysisPort {jarHash: retained.jarHash,bridgeHash: retained.bridgeHash,signal: activeSignal,+ timeoutMs: timeoutMs.value,}),);activeSignal.throwIfAborted();@@ -606,6 +615,7 @@ export class JadxProvider implements AndroidAnalysisPort {cause,request,timeout,+ timeoutMs: timeoutMs.value,signal: options?.signal,session,});diff --git a/src/android/JadxRelease.ts b/src/android/JadxRelease.tsindex 447886b52..5db3b3c99 100644--- a/src/android/JadxRelease.ts+++ b/src/android/JadxRelease.ts@@ -23,6 +23,12 @@ export const JADX_JAVA_RUNTIME_REMEDIATION =export const JADX_JVM_OPTIONS_REMEDIATION ="Set REA_JADX_HEAP_MIB to a positive integer (heap size in MiB) and REA_JADX_ACTIVE_PROCESSOR_COUNT to a positive integer within the JVM's signed 32-bit range.";+/** Whole-operation deadline used when REA_JADX_OPERATION_TIMEOUT_MS is unset. */+export const DEFAULT_JADX_OPERATION_TIMEOUT_MS = 120_000;++/** Remediation when the JADX operation deadline override is malformed. */+export const JADX_OPERATION_TIMEOUT_REMEDIATION = `Set REA_JADX_OPERATION_TIMEOUT_MS to a decimal millisecond count from 1 to 2147483647, or unset it to keep the ${String(DEFAULT_JADX_OPERATION_TIMEOUT_MS)} ms default.`;+/** Remediation when the host cannot run the Android JADX subprocess. */export const JADX_UNSUPPORTED_HOST_REMEDIATION ="Use Linux, macOS, or Windows x64 with its bundled native controls for Android JADX analysis.";diff --git a/src/android/JadxSession.ts b/src/android/JadxSession.tsindex 13f154b2e..7c413902e 100644--- a/src/android/JadxSession.ts+++ b/src/android/JadxSession.ts@@ -69,8 +69,10 @@ export class JadxSession {readonly jarHash: string;readonly bridgeHash: string;readonly signal: AbortSignal;+ /** Selected whole-operation deadline; also bounds each upstream call. */+ readonly timeoutMs: number;}): Promise<AnalysisExecution> {- const { request, target, snapshot, jarHash, signal } = context;+ const { request, target, snapshot, jarHash, signal, timeoutMs } = context;this.#partialContext = {operation: request.operation,selectedPath: request.input.path,@@ -105,7 +107,7 @@ export class JadxSession {request.operation,`Expected ${JADX_BRIDGE_IDENTITY.name} ${JADX_BRIDGE_IDENTITY.version}; server reported ${server?.name ?? "unknown"} ${server?.version ?? "unknown"}.`,);- const tools = this.#tools(request, target, signal);+ const tools = this.#tools(request, target, signal, timeoutMs);const runtime = jadxRuntimeSchema.parse(await tools.json("rea_jvm_status", {}),);@@ -206,15 +208,17 @@ export class JadxSession {request: AndroidRequest,target: BinaryTarget,signal: AbortSignal,+ timeoutMs: number,): JadxToolPort {const call = async (name: string,input: Readonly<Record<string, JsonValue>>,): Promise<string> => {signal.throwIfAborted();+ // Keep an explicit bound: omitting it falls back to the SDK's 60-second default.const response = await this.#client.callTool({ name, arguments: input },- { timeout: 120_000, signal },+ { timeout: timeoutMs, signal },);const observedResponse = jsonValueSchema.parse(response);const call = { operation: name, input, response: observedResponse };diff --git a/tests/boundary/android/jadxConfiguration.test.ts b/tests/boundary/android/jadxConfiguration.test.tsindex 7600ce44f..34bfebe06 100644--- a/tests/boundary/android/jadxConfiguration.test.ts+++ b/tests/boundary/android/jadxConfiguration.test.ts@@ -387,3 +387,45 @@ it("tags unavailable diagnostics with the boundary failure kind", async () => {if (availability.status !== "unavailable") throw new Error("unreachable");expect(availability.diagnostics["failure_kind"]).toBe("jar");});++it("reports the effective operation deadline and rejects unusable values", async () => {+ const root = await createTestTempDirectory("rea-jadx-deadline-");+ const jar = join(root, "jadx-headless-mcp.jar");+ const javaHome = await createFakeJdk(root);+ await writeJadxJarInventory(jar);+ const environment = { REA_JADX_MCP_JAR: jar, JAVA_HOME: javaHome };+ for (const [value, expected] of [+ [undefined, 120_000],+ ["1", 1],+ ["900000", 900_000],+ ["2147483647", 2_147_483_647],+ ] as const)+ await expect(+ inspectJadxAvailability({+ ...environment,+ ...(value === undefined+ ? {}+ : { REA_JADX_OPERATION_TIMEOUT_MS: value }),+ }),+ ).resolves.toMatchObject({+ status: "available",+ diagnostics: { operation_timeout_ms: expected },+ });+ // Node clamps timer delays above the signed 32-bit range to 1 ms.+ for (const value of ["", "0", "-1", "1.5", "1e3", " 5", "abc", "2147483648"])+ await expect(+ inspectJadxAvailability({+ ...environment,+ REA_JADX_OPERATION_TIMEOUT_MS: value,+ }),+ ).resolves.toMatchObject({+ status: "unavailable",+ code: "open_options_invalid",+ reason: expect.stringContaining("REA_JADX_OPERATION_TIMEOUT_MS"),+ diagnostics: {+ setting: "REA_JADX_OPERATION_TIMEOUT_MS",+ value,+ failure_kind: "operation_timeout",+ },+ });+});diff --git a/tests/boundary/android/jadxDoctor.test.ts b/tests/boundary/android/jadxDoctor.test.tsindex e053f66b5..a4806f9f2 100644--- a/tests/boundary/android/jadxDoctor.test.ts+++ b/tests/boundary/android/jadxDoctor.test.ts@@ -33,6 +33,7 @@ it("publishes REA_JADX_MCP_JAR as registration environment when the configured Jok: true,code: null,classification: "config_drift",+ details: { operation_timeout_ms: 120_000 },},],});@@ -214,6 +215,54 @@ it("publishes validated JVM resource overrides in the registration environment",});});+it("publishes and reports a validated operation deadline", async () => {+ const root = await createTestTempDirectory("rea-jadx-doctor-deadline-");+ const jar = join(root, "jadx-headless-mcp.jar");+ const javaHome = await createFakeJdk(root);+ await writeJadxJarInventory(jar);++ const inspection = await inspectJadxProvider({+ REA_JADX_MCP_JAR: jar,+ JAVA_HOME: javaHome,+ REA_JADX_OPERATION_TIMEOUT_MS: "900000",+ });++ expect(inspection.registrationEnvironment).toEqual({+ REA_JADX_MCP_JAR: jar,+ JAVA_HOME: javaHome,+ REA_JADX_OPERATION_TIMEOUT_MS: "900000",+ });+ expect(inspection.checks[0]).toMatchObject({+ ok: true,+ details: { operation_timeout_ms: 900_000 },+ });+});++it("guides deadline correction when REA_JADX_OPERATION_TIMEOUT_MS is invalid", async () => {+ const root = await createTestTempDirectory("rea-jadx-doctor-bad-deadline-");+ const jar = join(root, "jadx-headless-mcp.jar");+ const javaHome = await createFakeJdk(root);+ await writeJadxJarInventory(jar);++ const inspection = await inspectJadxProvider({+ REA_JADX_MCP_JAR: jar,+ JAVA_HOME: javaHome,+ REA_JADX_OPERATION_TIMEOUT_MS: "2147483648",+ });++ expect(inspection.available).toBe(false);+ expect(inspection.registrationEnvironment).toEqual({});+ expect(inspection.checks[0]).toMatchObject({+ ok: false,+ code: "open_options_invalid",+ classification: "config_drift",+ });+ expect(inspection.checks[0]?.remediation).toContain(+ "REA_JADX_OPERATION_TIMEOUT_MS",+ );+ expect(inspection.checks[0]?.remediation).not.toContain("REA_JADX_MCP_JAR");+});+it("guides JDK selection when the Java runtime is older than 17", async () => {const root = await createTestTempDirectory("rea-jadx-doctor-oldjdk-");const jar = join(root, "jadx-headless-mcp.jar");diff --git a/tests/boundary/process/jadxIntegration.test.ts b/tests/boundary/process/jadxIntegration.test.tsindex b497cc6cf..774244ba6 100644--- a/tests/boundary/process/jadxIntegration.test.ts+++ b/tests/boundary/process/jadxIntegration.test.ts@@ -1,20 +1,25 @@-import { expect, it as test, vi } from "vitest";+import { SdkErrorCode } from "@modelcontextprotocol/client";+import { expect, it as test, onTestFinished, vi } from "vitest";import { access, readFile, truncate, writeFile } from "node:fs/promises";+import { fileURLToPath } from "node:url";import { parseBinaryTarget } from "../../../src/application/BinaryTargetResolver.js";import { AndroidAnalysisService } from "../../../src/application/android/AndroidAnalysisService.js";import { JadxProvider } from "../../../src/android/JadxProvider.js";import { JadxSession } from "../../../src/android/JadxSession.js";import { androidResultSchemas } from "../../../src/domain/android/androidAnalysis.js";+import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";import { snapshotAndroidEngine } from "../../../src/android/AndroidTargetSnapshot.js";import { hashStableFile } from "../../../src/filesystem/StableFileHash.js";import { OwnedFileHandle } from "../../../src/filesystem/OwnedFileHandle.js";import { RegularFileCleanupFailure } from "../../../src/filesystem/OwnedRegularFile.js";import { PrivateRuntimeRoot } from "../../../src/process/PrivateRuntimeRoot.js";+import { spawnOwnedProviderProcess } from "../../../src/process/ProviderProcess.js";import {createJadxProtocolFixture as setup,verifyJadxFixtureCleanup as verifyCleanup,} from "../../fixtures/android/jadx.js";import { writeJadxJarInventory } from "../../fixtures/android/jadxJar.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";const it = test.skipIf(process.platform === "win32");@@ -668,6 +673,147 @@ it("cancels active and queued requests, cleans ownership and never launches a quawait verifyCleanup(launches);});+it("ends each queued stalled operation at the caller-selected deadline and cleans ownership", async () => {+ const { service, apk, launches, provider } = await setup(+ "stall",+ undefined,+ undefined,+ { REA_JADX_OPERATION_TIMEOUT_MS: "1500" },+ );+ const started = performance.now();+ // The second request waits behind the first; its deadline starts at the+ // queue front, so it gets its own engine launch and runtime reply.+ const outcomes = await Promise.all([+ service.execute("inspect_android_package", { path: apk }),+ service.execute("inspect_android_package", { path: apk }),+ ]);+ expect(performance.now() - started).toBeLessThan(20_000);+ for (const outcome of outcomes) {+ expect(outcome).toMatchObject({+ ok: false,+ error: {+ _tag: "AnalysisTimeoutError",+ timeoutMs: 1500,+ partialObservation: {+ calls: [expect.objectContaining({ operation: "rea_jvm_status" })],+ },+ },+ });+ if (outcome.ok) throw new Error("Expected the selected deadline");+ expect(projectAnalysisError(outcome.error)).toMatchObject({+ code: "provider_timeout",+ details: { timeout_ms: 1500 },+ });+ }+ expect(launches).toHaveLength(2);+ // The deadline path itself releases ownership before provider shutdown.+ await verifyCleanup(launches);+ await provider.close();+});++it("completes an operation under the largest accepted deadline", async () => {+ const { service, apk, provider, launches } = await setup(+ "normal",+ undefined,+ undefined,+ { REA_JADX_OPERATION_TIMEOUT_MS: "2147483647" },+ );+ const outcome = await service.execute("inspect_android_package", {+ path: apk,+ });+ expect(outcome.ok).toBe(true);+ await provider.close();+ await verifyCleanup(launches);+});++it.each(["", "2147483648"])(+ "rejects REA_JADX_OPERATION_TIMEOUT_MS=%j before probing or launching Java",+ async (value) => {+ const { service, apk, launches, javaProbeCount } = await setup(+ "normal",+ undefined,+ undefined,+ { REA_JADX_OPERATION_TIMEOUT_MS: value },+ );+ const outcome = await service.execute("inspect_android_package", {+ path: apk,+ });+ expect(outcome).toMatchObject({+ ok: false,+ error: {+ _tag: "AnalysisCapabilityUnavailableError",+ reason: expect.stringContaining("REA_JADX_OPERATION_TIMEOUT_MS"),+ },+ });+ expect(launches).toHaveLength(0);+ // The fake JDK records each module-listing probe; none may have run.+ await expect(javaProbeCount()).rejects.toMatchObject({ code: "ENOENT" });+ },+);++it("bounds each upstream call by the selected deadline instead of a fixed limit", async () => {+ // Provider workflows cannot reach the former fixed 120-second call limit in+ // a test, so exercise the session boundary that owns each upstream call.+ const { apk } = await setup();+ const target = await parseBinaryTarget(apk);+ if (!target.ok) throw target.error;+ const workspace = await createTestTempDirectory("rea-jadx-call-deadline-");+ const pids: number[] = [];+ const session = new JadxSession(+ {+ command: process.execPath,+ arguments: [],+ cwd: workspace,+ hostEnvironment: process.env,+ signal: new AbortController().signal,+ },+ async (options) => {+ const spawned = await spawnOwnedProviderProcess({+ ...options,+ command: process.execPath,+ arguments: [+ fileURLToPath(+ new URL("../../fixtures/android/jadx-mcp.mjs", import.meta.url),+ ),+ ],+ expectedCommand: process.execPath,+ env: { ...options.env, REA_FAKE_JADX_MODE: "stall" },+ });+ if (spawned.process.pid !== undefined) pids.push(spawned.process.pid);+ return spawned;+ },+ );+ onTestFinished(() => session.close());+ try {+ const started = performance.now();+ await expect(+ session.execute({+ request: { operation: "inspect_android_package", input: { path: apk } },+ target: target.value,+ snapshot: apk,+ jarHash: "0".repeat(64),+ bridgeHash: "0".repeat(64),+ signal: new AbortController().signal,+ timeoutMs: 300,+ }),+ ).rejects.toMatchObject({+ code: SdkErrorCode.RequestTimeout,+ data: { timeout: 300 },+ });+ expect(performance.now() - started).toBeLessThan(10_000);+ expect(session.partialObservation()?.calls).toEqual([+ expect.objectContaining({ operation: "rea_jvm_status" }),+ ]);+ } finally {+ await session.close();+ }+ expect(pids).toHaveLength(1);+ for (const pid of pids)+ expect(() => process.kill(-pid, 0)).toThrowError(+ expect.objectContaining({ code: "ESRCH" }),+ );+});+it("reports missing explicit tools without trying to install or launch them", async () => {const { apk } = await setup();const provider = new JadxProvider({}, () => {diff --git a/tests/fixtures/android/jadx.ts b/tests/fixtures/android/jadx.tsindex 373f3a624..0e307492d 100644--- a/tests/fixtures/android/jadx.ts+++ b/tests/fixtures/android/jadx.ts@@ -28,6 +28,7 @@ export const createJadxProtocolFixture = async (mode = "normal",cleanupFailure?: () => boolean,inventory?: { readonly classCount?: number },+ settings: Readonly<Record<string, string>> = {},) => {const root = await createTestTempDirectory("rea-android-boundary-");const apk = join(root, "fixture.apk");@@ -52,10 +53,17 @@ export const createJadxProtocolFixture = async (javaToolOptions: string | undefined;legacyJavaOptions: string | undefined;}[] = [];+ // Inherit the host environment for process launch, but take JADX settings+ // only from this fixture so a developer's shell cannot change the provider.const environment: NodeJS.ProcessEnv = {- ...process.env,+ ...Object.fromEntries(+ Object.entries(process.env).filter(+ ([name]) => !name.startsWith("REA_JADX_"),+ ),+ ),JAVA_HOME: javaHome,REA_JADX_MCP_JAR: jar,+ ...settings,};const provider = createAndroidAnalysisProvider(environment,