Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(android): retain archive admission ownership through cleanup retries
morluto300905c11be1
diff --git a/src/android/JadxConfiguration.ts b/src/android/JadxConfiguration.tsindex 37b20f4e1..bcc93ad23 100644--- a/src/android/JadxConfiguration.ts+++ b/src/android/JadxConfiguration.ts@@ -11,12 +11,24 @@ import { systemWindowsNativeAuthority } from "../windows/WindowsNativeLoader.js"import { providerStartupTimeoutSchema } from "../config/providerStartupTimeout.js";import {AnalysisCancelledError,+ AnalysisTimeoutError,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 { AnalysisError } from "../domain/analysisErrorBase.js";+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";+import { ProviderCleanupError } from "../domain/providerCleanupError.js";+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";+import {+ ArtifactFileCancelled,+ ArtifactFileCleanupFailure,+ bindArtifactFileCleanup,+ withArtifactRegularFile,+} from "../artifacts/ArtifactFileOperation.js";+import { analysisClientFailureForOperation } from "../providers/AnalysisClientFailure.js";import { ZipArtifactReader } from "../artifacts/ZipArtifactReader.js";import type { DoctorProviderCheck } from "../application/Doctor.js";import {@@ -275,11 +287,11 @@ const validateJadxConfigurationContents = async (): Promise<void> => {throwIfJadxInterrupted(options.signal);await inspectJavaRuntime(configuration.java, environment, options);- await requireEngineArchive(configuration.jar, options.signal);+ await requireEngineArchive(configuration.jar, options);};const projectConfigurationFailure = (- operation: AndroidOperation,+ operation: string,cause: JadxConfigurationFailure,): AnalysisCapabilityUnavailableError => {const output = cause.diagnostics;@@ -311,49 +323,170 @@ const projectConfigurationFailure = (const requireEngineArchive = async (jar: string,- signal?: AbortSignal,+ options: JadxJavaProbeOptions,): Promise<void> => {- // 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);+ const operation = options.operation ?? "inspect_jadx_configuration";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,- },- "jar",- cause,+ await options.resourceOwner.run(() =>+ withArtifactRegularFile(+ jar,+ {+ retain: ({ lease, resource }) =>+ options.resourceOwner.retain(+ {+ close: () => lease.release(),+ },+ resource,+ ),+ },+ options.signal,+ async (handle) => {+ try {+ // Metadata enumeration borrows this descriptor. The file workflow+ // alone owns admission, final close, cancellation and failed retry.+ const reader = new ZipArtifactReader(+ jar,+ "zip",+ JAR_METADATA_READ_MAX_BYTES,+ { handle, initial: await handle.stat() },+ );+ 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",+ ]);+ for await (const entry of reader.entries(options.signal)) {+ if (entry.kind === "file" && !entry.encrypted)+ missing.delete(entry.path);+ if (missing.size === 0) return;+ }+ 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],+ },+ "jar",+ );+ } catch (cause: unknown) {+ if (+ cause instanceof JadxConfigurationFailure ||+ (cause instanceof ArtifactReaderFailure &&+ cause.reason === "cancelled")+ )+ throw cause;+ throw archiveInspectionFailure(jar, cause);+ }+ },+ ),);- } finally {- await reader.close();+ } catch (cause: unknown) {+ if (cause instanceof ArtifactFileCleanupFailure) {+ const physical = cause.fileCleanupFailure;+ const cleanup = new ProviderCleanupError(+ "jadx",+ [jar],+ {+ phase: "jar-inspection",+ ...(physical.outcome.kind === "completed"+ ? { archive_observation: { jar_path: jar, required_classes: true } }+ : {}),+ },+ { operation, cause: physical.cleanupCause },+ );+ bindArtifactFileCleanup(cause, cleanup);+ const primary =+ physical.outcome.kind === "failed"+ ? archiveAnalysisFailure(jar, physical.outcome.cause, options)+ : physical.completionCancellation === undefined+ ? undefined+ : archiveCancellation(+ physical.completionCancellation.reason,+ options,+ {+ archive_observation: {+ jar_path: jar,+ required_classes: true,+ },+ },+ );+ if (primary === undefined) throw cleanup;+ throw analysisErrorWithCleanupFailure(+ primary,+ cleanup,+ operation,+ ).bindCleanupDependencies([primary, cleanup]);+ }+ if (cause instanceof ArtifactFileCancelled) {+ throw archiveCancellation(cause.fileCancellation.reason, options, {+ archive_observation: { jar_path: jar, required_classes: true },+ });+ }+ if (cause instanceof ArtifactReaderFailure) {+ if (cause.reason === "cancelled")+ throw archiveCancellation(cause.cancellation?.reason, options);+ throw analysisClientFailureForOperation(cause, "jadx", operation);+ }+ if (+ cause instanceof AnalysisError ||+ cause instanceof JadxConfigurationFailure+ )+ throw cause;+ throw archiveInspectionFailure(jar, cause);}- 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 archiveInspectionFailure = (jar: string, cause: unknown) => {+ const reason = cause instanceof Error ? cause.message : String(cause);+ return 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,+ },"jar",+ cause,);};+const archiveAnalysisFailure = (+ jar: string,+ cause: unknown,+ options: JadxJavaProbeOptions,+): AnalysisError => {+ if (cause instanceof AnalysisError) return cause;+ if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled")+ return archiveCancellation(cause.cancellation?.reason, options);+ return projectConfigurationFailure(+ options.operation ?? "inspect_jadx_configuration",+ cause instanceof JadxConfigurationFailure+ ? cause+ : archiveInspectionFailure(jar, cause),+ );+};++const archiveCancellation = (+ reason: unknown,+ options: JadxJavaProbeOptions,+ diagnostics?: Readonly<Record<string, JsonValue>>,+) => {+ const operation = options.operation ?? "inspect_jadx_configuration";+ return options.operationDeadline?.signal.aborted === true &&+ reason === options.operationDeadline.signal.reason+ ? new AnalysisTimeoutError(operation, options.operationDeadline.timeoutMs, {+ cause: reason,+ diagnostics,+ })+ : new AnalysisCancelledError(operation, { cause: reason, diagnostics });+};+const requireSupportedHost = (): void => {if (process.platform === "linux" || process.platform === "darwin") return;if (process.platform === "win32" && process.arch === "x64") {diff --git a/tests/boundary/android/jadxArchiveLifecycle.test.ts b/tests/boundary/android/jadxArchiveLifecycle.test.tsnew file mode 100644index 000000000..f7e4850f4--- /dev/null+++ b/tests/boundary/android/jadxArchiveLifecycle.test.ts@@ -0,0 +1,321 @@+import { inspectJadxProvider } from "../../../src/android/JadxDoctor.js";+import { createInspectionResources } from "../../fixtures/inspectionResources.js";+import { stat, writeFile } from "node:fs/promises";+import { expect, it as test, vi } from "vitest";+import { createJadxProtocolFixture } from "../../fixtures/android/jadx.js";+import { writeOrderedZip } from "../../fixtures/artifactEntryOrder.js";+import { OwnedFileHandle } from "../../../src/filesystem/OwnedFileHandle.js";+import { AnalysisError } from "../../../src/domain/analysisErrorBase.js";++const it = test.skipIf(process.platform === "win32");++it.each(["valid", "malformed", "missing-classes"] as const)(+ "retains exact archive cleanup and its %s admission outcome through retry",+ async (inventory) => {+ const f = await createJadxProtocolFixture();+ if (inventory === "malformed") await writeFile(f.jar, "not a zip");+ if (inventory === "missing-classes")+ await writeOrderedZip(f.jar, ["unrelated/Library.class"]);+ const identity = await stat(f.jar);+ const original = OwnedFileHandle.prototype.close;+ const handles = new Set<OwnedFileHandle>();+ let allowClose = false;+ const closeFailure = new Error("injected archive descriptor close failure");+ const close = vi+ .spyOn(OwnedFileHandle.prototype, "close")+ .mockImplementation(async function (this: OwnedFileHandle) {+ if (!handles.has(this) && this.handle.fd >= 0) {+ const observed = await this.handle.stat();+ if (observed.dev === identity.dev && observed.ino === identity.ino)+ handles.add(this);+ }+ if (handles.has(this) && !allowClose) throw closeFailure;+ await original.call(this);+ });+ try {+ const error: unknown = await f.provider+ .inspectAvailability()+ .catch((cause: unknown) => cause);+ expect(error).toBeInstanceOf(AnalysisError);+ if (!(error instanceof AnalysisError))+ throw new Error("Expected retained archive cleanup");+ expect(error.cleanupIncomplete).toBe(true);+ expect(error.cleanupResources).toEqual([f.jar]);+ expect(handles.size).toBe(1);+ expect([...handles][0]?.handle.fd).toBeGreaterThanOrEqual(0);+ if (inventory === "valid") {+ expect(error.diagnostics).toMatchObject({+ archive_observation: { jar_path: f.jar, required_classes: true },+ });+ } else {+ expect(error.cleanupPrimary).toMatchObject({+ _tag: "AnalysisCapabilityUnavailableError",+ diagnostics: {+ failure_kind: "jar",+ failure_code:+ inventory === "malformed"+ ? "version_unresolved"+ : "unsupported_version",+ },+ });+ }+ const probes = await f.javaProbeCount();+ const refused: unknown = await f.provider+ .inspectAvailability()+ .catch((cause: unknown) => cause);+ expect(refused).toMatchObject({ cleanupIncomplete: true });+ expect(await f.javaProbeCount()).toBe(probes);+ const shutdown: unknown = await f.provider+ .close()+ .catch((cause: unknown) => cause);+ expect(shutdown).toMatchObject({ cleanupIncomplete: true });+ expect(f.launches).toEqual([]);+ allowClose = true;+ await f.provider.close();+ expect([...handles].every((owner) => owner.handle.fd === -1)).toBe(true);+ expect(error.cleanupIncomplete).toBe(false);+ expect(error.cleanupResources).toEqual([]);+ if (refused instanceof AnalysisError)+ expect(refused.cleanupIncomplete).toBe(false);+ if (shutdown instanceof AnalysisError)+ expect(shutdown.cleanupIncomplete).toBe(false);+ } finally {+ allowClose = true;+ close.mockRestore();+ await f.provider.close();+ for (const owner of handles) await original.call(owner);+ }+ },+);++it.each([+ { valid: true, failsClose: false },+ { valid: true, failsClose: true },+ { valid: false, failsClose: false },+ { valid: false, failsClose: true },+])(+ "owns late cancellation during archive close (%j)",+ async ({ valid, failsClose }) => {+ const f = await createJadxProtocolFixture();+ if (!valid) await writeOrderedZip(f.jar, ["unrelated.class"]);+ const caller = new AbortController();+ const reason = { caller: "during final archive close" };+ const identity = await stat(f.jar);+ const original = OwnedFileHandle.prototype.close;+ let owner: OwnedFileHandle | undefined;+ let allowClose = false;+ const close = vi+ .spyOn(OwnedFileHandle.prototype, "close")+ .mockImplementation(async function (this: OwnedFileHandle) {+ const observed = await this.handle.stat();+ if (observed.dev === identity.dev && observed.ino === identity.ino) {+ owner = this;+ caller.abort(reason);+ if (failsClose && !allowClose)+ throw new Error("injected close failure after cancellation");+ }+ await original.call(this);+ });+ try {+ const outcome: unknown = await f.provider+ .inspectAvailability(caller.signal)+ .catch((cause: unknown) => cause);+ expect(owner).toBeDefined();+ if (!failsClose && !valid) {+ expect(outcome).toMatchObject({+ status: "unavailable",+ code: "unsupported_version",+ });+ } else {+ expect(outcome).toBeInstanceOf(AnalysisError);+ if (!(outcome instanceof AnalysisError))+ throw new Error("Expected owned lifecycle outcome");+ const primary = failsClose ? outcome.cleanupPrimary : outcome;+ if (valid) {+ expect(primary).toMatchObject({ _tag: "AnalysisCancelledError" });+ expect(primary?.cause).toBe(reason);+ expect(primary?.diagnostics).toMatchObject({+ archive_observation: { required_classes: true },+ });+ } else {+ expect(primary).toMatchObject({+ _tag: "AnalysisCapabilityUnavailableError",+ diagnostics: { failure_code: "unsupported_version" },+ });+ }+ expect(outcome.cleanupIncomplete).toBe(failsClose);+ allowClose = true;+ await f.provider.close();+ expect(outcome.cleanupIncomplete).toBe(false);+ }+ expect(f.launches).toEqual([]);+ expect(owner?.handle.fd).toBe(-1);+ } finally {+ allowClose = true;+ close.mockRestore();+ await f.provider.close();+ if (owner !== undefined) await original.call(owner);+ }+ },+);++it("resolves mixed archive owners independently without reclosing a released peer", async () => {+ const f = await createJadxProtocolFixture();+ const identity = await stat(f.jar);+ const original = OwnedFileHandle.prototype.close;+ const handles: OwnedFileHandle[] = [];+ const attempts = new Map<OwnedFileHandle, number>();+ const allowed = new Set<OwnedFileHandle>();+ let release: () => void = () => {};+ const held = new Promise<void>((resolve) => {+ release = resolve;+ });+ let entered: () => void = () => {};+ const bothClosing = new Promise<void>((resolve) => {+ entered = resolve;+ });+ const close = vi+ .spyOn(OwnedFileHandle.prototype, "close")+ .mockImplementation(async function (this: OwnedFileHandle) {+ if (!handles.includes(this) && this.handle.fd >= 0) {+ const observed = await this.handle.stat();+ if (observed.dev === identity.dev && observed.ino === identity.ino)+ handles.push(this);+ }+ if (handles.includes(this)) {+ attempts.set(this, (attempts.get(this) ?? 0) + 1);+ if (handles.length === 2) entered();+ await held;+ if (!allowed.has(this))+ throw new Error("injected concurrent archive close failure");+ }+ await original.call(this);+ });+ const first = f.provider+ .inspectAvailability()+ .catch((cause: unknown) => cause);+ const second = f.provider+ .inspectAvailability()+ .catch((cause: unknown) => cause);+ try {+ await bothClosing;+ release();+ const errors = await Promise.all([first, second]);+ expect(+ errors.every(+ (error) => error instanceof AnalysisError && error.cleanupIncomplete,+ ),+ ).toBe(true);+ const [released, pending] = handles;+ if (released === undefined || pending === undefined)+ throw new Error("Expected two exact archive owners");+ allowed.add(released);+ const aggregate: unknown = await f.provider+ .close()+ .catch((cause: unknown) => cause);+ expect(aggregate).toMatchObject({+ cleanupIncomplete: true,+ cleanupResources: [f.jar],+ });+ expect(+ errors.filter(+ (error) => error instanceof AnalysisError && error.cleanupIncomplete,+ ),+ ).toHaveLength(1);+ expect(released.handle.fd).toBe(-1);+ expect(pending.handle.fd).toBeGreaterThanOrEqual(0);+ const releasedAttempts = attempts.get(released);+ allowed.add(pending);+ await f.provider.close();+ expect(attempts.get(released)).toBe(releasedAttempts);+ expect(+ errors.every(+ (error) => error instanceof AnalysisError && !error.cleanupIncomplete,+ ),+ ).toBe(true);+ if (!(aggregate instanceof AnalysisError))+ throw new Error("Expected retained aggregate cleanup");+ expect(aggregate.cleanupIncomplete).toBe(false);+ expect(aggregate.cleanupResources).toEqual([]);+ expect(f.launches).toEqual([]);+ } finally {+ release();+ close.mockRestore();+ await Promise.allSettled([first, second]);+ await f.provider.close();+ for (const owner of handles) await original.call(owner);+ }+});++it("joins independent doctor archive finalization and retries its exact failed close", async () => {+ const f = await createJadxProtocolFixture();+ const resources = createInspectionResources();+ const identity = await stat(f.jar);+ const original = OwnedFileHandle.prototype.close;+ let owner: OwnedFileHandle | undefined;+ let allowClose = false;+ let entered: () => void = () => {};+ const closing = new Promise<void>((resolve) => {+ entered = resolve;+ });+ let release: () => void = () => {};+ const held = new Promise<void>((resolve) => {+ release = resolve;+ });+ const close = vi+ .spyOn(OwnedFileHandle.prototype, "close")+ .mockImplementation(async function (this: OwnedFileHandle) {+ const observed = await this.handle.stat();+ if (observed.dev === identity.dev && observed.ino === identity.ino) {+ owner = this;+ entered();+ await held;+ if (!allowClose)+ throw new Error("injected independent doctor archive close failure");+ }+ await original.call(this);+ });+ const inspection = inspectJadxProvider(f.environment, resources.owner).catch(+ (cause: unknown) => cause,+ );+ let settled = false;+ let shutdown: Promise<unknown> | undefined;+ try {+ await closing;+ shutdown = resources.close().then(+ () => {+ settled = true;+ },+ (cause: unknown) => {+ settled = true;+ return cause;+ },+ );+ await new Promise<void>((resolve) => setImmediate(resolve));+ expect(settled).toBe(false);+ release();+ const error = await inspection;+ expect(error).toMatchObject({+ cleanupIncomplete: true,+ cleanupResources: [f.jar],+ });+ expect(await shutdown).toMatchObject({ cleanup: { resources: [f.jar] } });+ expect(owner?.handle.fd).toBeGreaterThanOrEqual(0);+ allowClose = true;+ await resources.close();+ expect(owner?.handle.fd).toBe(-1);+ if (!(error instanceof AnalysisError))+ throw new Error("Expected owned doctor failure");+ expect(error.cleanupIncomplete).toBe(false);+ expect(error.cleanupResources).toEqual([]);+ expect(f.launches).toEqual([]);+ } finally {+ release();+ allowClose = true;+ close.mockRestore();+ await inspection;+ await shutdown;+ await resources.close();+ if (owner !== undefined) await original.call(owner);+ }+});diff --git a/tests/boundary/process/jadxJavaLifecycle.test.ts b/tests/boundary/process/jadxJavaLifecycle.test.tsindex 7e4608800..52eb19e0d 100644--- a/tests/boundary/process/jadxJavaLifecycle.test.ts+++ b/tests/boundary/process/jadxJavaLifecycle.test.ts@@ -1,4 +1,4 @@-import { ZipArtifactReader } from "../../../src/artifacts/ZipArtifactReader.js";+import { OwnedFileHandle } from "../../../src/filesystem/OwnedFileHandle.js";import { beforeAll, expect, it as test, vi } from "vitest";import { inspectJadxJava } from "../../../src/android/JadxJavaProbe.js";import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";@@ -11,7 +11,7 @@ import {prepareProcessOwnershipInspection,} from "../../../src/process/ProcessOwnershipObservation.js";import { createInspectionResources } from "../../fixtures/inspectionResources.js";-import { writeFile, readFile } from "node:fs/promises";+import { writeFile, readFile, stat } from "node:fs/promises";import { dirname, join } from "node:path";import { createJadxProtocolFixture } from "../../fixtures/android/jadx.js";import { inspectJadxProvider } from "../../../src/android/JadxDoctor.js";@@ -463,15 +463,21 @@ it("joins the whole availability call while its final archive close is held", asconst held = new Promise<void>((resolve) => {release = resolve;});- const original = ZipArtifactReader.prototype.close;+ const identity = await stat(f.jar);+ const original = OwnedFileHandle.prototype.close;const archive = vi- .spyOn(ZipArtifactReader.prototype, "close")- .mockImplementationOnce(async function (this: ZipArtifactReader) {- started();- await held;+ .spyOn(OwnedFileHandle.prototype, "close")+ .mockImplementation(async function (this: OwnedFileHandle) {+ const observed = await this.handle.stat();+ if (observed.dev === identity.dev && observed.ino === identity.ino) {+ started();+ await held;+ }await original.call(this);});- const availability = f.provider.inspectAvailability();+ const availability = f.provider+ .inspectAvailability()+ .catch((cause: unknown) => cause);let completed = false;let close: Promise<void> | undefined;try {@@ -483,7 +489,9 @@ it("joins the whole availability call while its final archive close is held", asexpect(completed).toBe(false);release();await close;- expect(await availability).toMatchObject({ status: "available" });+ expect(await availability).toMatchObject({+ _tag: "AnalysisCancelledError",+ });} finally {release();archive.mockRestore();