rea-agents 4.1.0 → 5.0.0

package/dist/android/JadxProvider.js

@@ -1,14 +1,18 @@
 import { z } from "zod";
+import { chmod, copyFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisInputError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../domain/providerCleanupError.js";
 import { err, ok } from "../domain/result.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
-import { snapshotAndroidEngine, snapshotAndroidTarget, } from "./AndroidTargetSnapshot.js";
+import { snapshotAndroidEngine, hashAndroidFile, snapshotAndroidTarget, } from "./AndroidTargetSnapshot.js";
 import { resolveJadxConfiguration } from "./JadxConfiguration.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));
 const waitForTurn = (predecessor, request, signal) => new Promise((resolve, reject) => {
     const abort = () => reject(new AnalysisCancelledError(request.operation));
     signal?.addEventListener("abort", abort, { once: true });
@@ -75,44 +79,81 @@ const cleanup = async (session, root, previous) => {
     }
     return previous;
 };
-/** One queued engine per REA instance, with a fresh owned workspace for every request. */
+/** One serialized, immutable APK session per REA instance, retired on idle or shutdown. */
 export class JadxProvider {
     environment;
     launcher;
     #tail = Promise.resolve();
     #cleanupFailure;
+    #retained;
+    #idle;
+    #shutdown = new AbortController();
+    #closePromise;
     constructor(environment = process.env, launcher) {
         this.environment = environment;
         this.launcher = launcher;
     }
     /** Serialize expensive work and bind both raw and normalized results to the APK. */
     async execute(target, request, options) {
+        if (this.#shutdown.signal.aborted)
+            return err(new AnalysisCancelledError(request.operation));
+        const signal = options?.signal === undefined
+            ? this.#shutdown.signal
+            : AbortSignal.any([options.signal, this.#shutdown.signal]);
         const predecessor = this.#tail;
         let release = () => { };
         this.#tail = new Promise((resolve) => {
             release = resolve;
         });
         try {
-            await waitForTurn(predecessor, request, options?.signal);
+            await waitForTurn(predecessor, request, signal);
         }
         catch {
             void predecessor.then(release);
             return err(new AnalysisCancelledError(request.operation));
         }
         try {
-            if (options?.signal?.aborted === true)
+            if (signal.aborted)
                 return err(new AnalysisCancelledError(request.operation));
             if (this.#cleanupFailure !== undefined)
                 return err(this.#cleanupFailure);
-            const outcome = await this.#execute(target, request, options);
+            clearTimeout(this.#idle);
+            const outcome = await this.#execute(target, request, { signal });
             if (!outcome.ok && outcome.error.cleanupIncomplete)
                 this.#cleanupFailure = outcome.error;
+            if (outcome.ok)
+                this.#scheduleIdle();
             return outcome;
         }
         finally {
             release();
         }
     }
+    /** Cancel queued/active operations and join the owned engine and workspace cleanup. */
+    close() {
+        this.#shutdown.abort();
+        clearTimeout(this.#idle);
+        this.#closePromise ??= this.#tail.then(() => this.#retire());
+        return this.#closePromise;
+    }
+    async #retire() {
+        if (this.#cleanupFailure !== undefined)
+            throw this.#cleanupFailure;
+        const retained = this.#retained;
+        this.#retained = undefined;
+        const result = await cleanup(retained?.session, retained?.root, ok(undefined));
+        if (!result.ok) {
+            this.#cleanupFailure = result.error;
+            throw result.error;
+        }
+    }
+    #scheduleIdle() {
+        this.#idle = setTimeout(() => {
+            const retirement = this.#tail.then(() => this.#retire());
+            this.#tail = retirement.catch(() => undefined);
+        }, 60_000);
+        this.#idle.unref();
+    }
     async #execute(target, request, options) {
         const timeout = AbortSignal.timeout(OPERATION_TIMEOUT_MS);
         const signal = options?.signal === undefined
@@ -126,35 +167,79 @@ export class JadxProvider {
                 throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Target ${target.path} is ${target.format}; provide one standalone APK.`);
             const configuration = await resolveJadxConfiguration(this.environment, request.operation);
             signal.throwIfAborted();
-            root = await PrivateRuntimeRoot.create({ prefix: "rea-android-" });
-            const engine = await snapshotAndroidEngine(configuration.jar, root.path);
-            const snapshot = await snapshotAndroidTarget(target.path, target.sha256, root.path, request.operation);
-            signal.throwIfAborted();
-            session = new JadxSession({
-                command: configuration.java,
-                arguments: [
-                    "-Xmx512m",
-                    "-XX:ActiveProcessorCount=1",
-                    "-jar",
-                    engine.path,
-                    "--threads",
-                    "1",
-                    "--max-source-bytes",
-                    "1048576",
-                    "--decompile-timeout-ms",
-                    "90000",
+            const jarHash = await hashAndroidFile(configuration.jar);
+            const bridgeHash = await hashAndroidFile(BRIDGE_SOURCE);
+            if ((await hashAndroidFile(target.path)) !== target.sha256)
+                throw new AnalysisInputError(request.operation, undefined, [
+                    {
+                        path: ["path"],
+                        reason: "invalid_value",
+                        message: "APK bytes changed after admission; retry against a stable file.",
+                    },
+                ]);
+            const key = JSON.stringify({
+                path: target.path,
+                sha256: target.sha256,
+                jar: configuration.jar,
+                jarHash,
+                bridgeHash,
+                java: configuration.java,
+                arguments: configuration.jvmArguments,
+                options: [
+                    this.environment.JAVA_TOOL_OPTIONS,
+                    this.environment._JAVA_OPTIONS,
+                    this.environment.JDK_JAVA_OPTIONS,
+                    this.environment.PATH,
+                    this.environment.JAVA_HOME,
                 ],
-                cwd: root.path,
-                hostEnvironment: this.environment,
-                env: { _JAVA_OPTIONS: "-Xmx512m -XX:ActiveProcessorCount=1" },
-            }, this.launcher);
+            });
+            if (this.#retained !== undefined && this.#retained.key !== key)
+                await this.#retire();
+            let retained = this.#retained;
+            if (retained === undefined) {
+                root = await PrivateRuntimeRoot.create({ prefix: "rea-android-" });
+                const engine = await snapshotAndroidEngine(configuration.jar, jarHash, root.path, request.operation);
+                const snapshot = await snapshotAndroidTarget(target.path, target.sha256, root.path, request.operation);
+                const bridge = join(root.path, "ReaJadxBridge.java");
+                await copyFile(BRIDGE_SOURCE, bridge);
+                await chmod(bridge, 0o400);
+                if ((await hashAndroidFile(bridge)) !== bridgeHash)
+                    throw new AnalysisCapabilityUnavailableError("jadx", request.operation, "REA Android bridge bytes changed during admission; retry with a stable installation.");
+                signal.throwIfAborted();
+                session = new JadxSession({
+                    command: configuration.java,
+                    arguments: [
+                        ...configuration.jvmArguments,
+                        "--class-path",
+                        engine.path,
+                        bridge,
+                    ],
+                    cwd: root.path,
+                    hostEnvironment: this.environment,
+                }, this.launcher);
+                retained = {
+                    key,
+                    root,
+                    session,
+                    snapshot,
+                    jarHash: engine.sha256,
+                    bridgeHash,
+                };
+            }
+            root = retained.root;
+            session = retained.session;
+            const { snapshot } = retained;
             outcome = ok(await session.execute({
                 request,
                 target,
                 snapshot,
-                jarHash: engine.sha256,
+                jarHash: retained.jarHash,
+                bridgeHash: retained.bridgeHash,
                 signal,
             }));
+            signal.throwIfAborted();
+            this.#retained = retained;
+            return outcome;
         }
         catch (cause) {
             outcome = err(executionError({
@@ -165,6 +250,10 @@ export class JadxProvider {
                 session,
             }));
         }
+        // An existing session also needs retirement when admission fails before selection.
+        root ??= this.#retained?.root;
+        session ??= this.#retained?.session;
+        this.#retained = undefined;
         return cleanup(session, root, outcome);
     }
 }

package/dist/android/JadxRelease.js

@@ -5,6 +5,13 @@ export const JADX_RELEASE = Object.freeze({
     sha256: "6e5eacf500b64292bfb73c49797c1958f6ee44646e43e868039ae7feb573ff75",
     url: "https://github.com/1013503897/jadx-headless-mcp/releases/download/v0.7.1/jadx-headless-mcp-0.7.1-all.jar",
 });
+/** Identity of REA's metadata bridge, distinct from the producing engine. */
+export const JADX_BRIDGE_IDENTITY = Object.freeze({
+    name: "rea-jadx-bridge",
+    version: "1",
+});
+/** Remediation when `REA_JADX_MCP_JAR` is missing or not an absolute path. */
+export const JADX_JAR_CONFIGURATION_REMEDIATION = `Set REA_JADX_MCP_JAR to the absolute path of a caller-supplied jadx-headless-mcp ${JADX_RELEASE.version} JAR. REA does not download or install it.`;
 /** Producing engine identity used by Evidence and the generated product catalog. */
 export const JADX_PROVIDER_IDENTITY = Object.freeze({
     id: "jadx",
@@ -15,5 +22,6 @@ export const JADX_PROVIDER_IDENTITY = Object.freeze({
 export const JADX_LIMITATIONS = [
     "Static decompiler observations do not establish runtime behavior; the APK is never executed.",
     "Method signatures use provider display types; exact DEX descriptors and instruction offsets are unavailable. Overload indices are local to this engine and artifact.",
+    "Class inventories use parsed metadata before code generation, including synthetic members that may be omitted from decompiled source. Source positions remain unknown.",
     "Manifest summary fields are extracted by the upstream engine; decoded XML is retained for verification. APK signatures, split APKs, native libraries and Android runtime capture are not verified by this provider.",
 ];

package/dist/android/JadxSession.js

@@ -5,13 +5,13 @@ import { jsonValueSchema } from "../domain/jsonValue.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { analyzeJadxRequest } from "./JadxAnalysis.js";
 import { JadxMcpTransport } from "./JadxMcpTransport.js";
-import { jadxLoadSchema, parseJadxEnvelope, parseJadxJson, } from "./JadxProtocol.js";
-import { JADX_RELEASE, JADX_PROVIDER_IDENTITY, JADX_LIMITATIONS, } from "./JadxRelease.js";
+import { jadxLoadSchema, jadxRuntimeSchema, parseJadxEnvelope, parseJadxJson, } from "./JadxProtocol.js";
+import { JADX_BRIDGE_IDENTITY, JADX_RELEASE, JADX_PROVIDER_IDENTITY, JADX_LIMITATIONS, } from "./JadxRelease.js";
 /** One owned engine connection; its wire protocol stays inside the Android adapter. */
 export class JadxSession {
     transport;
     #client = new Client({ name: "rea-android-adapter", version: "1" });
-    #raw = [];
+    #loaded;
     constructor(options, launcher) {
         this.transport = new JadxMcpTransport(options, launcher);
     }
@@ -24,30 +24,44 @@ export class JadxSession {
         signal.addEventListener("abort", abort, { once: true });
         try {
             signal.throwIfAborted();
-            await this.#client.connect(this.transport, { timeout: 30_000 });
+            this.transport.beginOperation();
+            const raw = [];
+            if (this.#loaded === undefined)
+                await this.#client.connect(this.transport, { timeout: 30_000 });
             const server = this.#client.getServerVersion();
-            if (server?.name !== "jadx-headless-mcp" ||
-                server.version !== JADX_RELEASE.version)
-                throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected jadx-headless-mcp ${JADX_RELEASE.version}; server reported ${server?.name ?? "unknown"} ${server?.version ?? "unknown"}.`);
-            const tools = this.#tools(request, target, signal);
-            const loaded = jadxLoadSchema.parse(await tools.json("load_apk", {
-                path: snapshot,
-                threads: 1,
-                resources: "full",
-            }));
+            if (server?.name !== JADX_BRIDGE_IDENTITY.name ||
+                server.version !== JADX_BRIDGE_IDENTITY.version)
+                throw new AnalysisCapabilityUnavailableError("jadx", 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, raw);
+            const runtime = jadxRuntimeSchema.parse(await tools.json("rea_jvm_status", {}));
+            if (runtime.engine_reported_version !== JADX_RELEASE.version)
+                throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected engine ${JADX_RELEASE.version}; JAR reported ${runtime.engine_reported_version}.`);
+            const loaded = this.#loaded ??
+                jadxLoadSchema.parse(await tools.json("load_apk", {
+                    path: snapshot,
+                    threads: 1,
+                    resources: "full",
+                }));
             if (loaded.apk_path !== snapshot)
                 throw new AnalysisOutputError(request.operation, "JADX loaded a different APK path than the admitted snapshot");
+            this.#loaded = loaded;
             const engine = {
                 name: "jadx-headless-mcp",
-                version: "0.7.1",
+                version: runtime.engine_reported_version,
                 artifact_sha256: jarHash,
                 source_revision: jarHash === JADX_RELEASE.sha256 ? JADX_RELEASE.revision : null,
                 worker_count: 1,
-                heap_limit_mib: 512,
+                heap_limit_mib: Math.floor(runtime.max_heap_bytes / (1024 * 1024)) || null,
             };
             const result = await analyzeJadxRequest(tools, request, loaded, engine);
             return createAnalysisExecution(result, JADX_PROVIDER_IDENTITY, {
-                rawResult: { server, jar_sha256: jarHash, calls: this.#raw },
+                rawResult: {
+                    server,
+                    bridge_sha256: context.bridgeHash,
+                    jar_sha256: jarHash,
+                    loaded,
+                    calls: raw,
+                },
                 subject: target,
                 limitations: JADX_LIMITATIONS,
                 locations: request.operation === "inspect_android_package"
@@ -68,12 +82,12 @@ export class JadxSession {
             await this.transport.close();
         }
     }
-    #tools(request, target, signal) {
+    #tools(request, target, signal, raw) {
         const call = async (name, input) => {
             signal.throwIfAborted();
             const response = await this.#client.callTool({ name, arguments: input }, { timeout: 120_000, signal });
             const envelope = parseJadxEnvelope(response, request.operation);
-            this.#raw.push({
+            raw.push({
                 operation: name,
                 input,
                 response: jsonValueSchema.parse(response),

package/dist/application/AppBundleExecutable.js

@@ -0,0 +1,141 @@
+import { execFile } from "node:child_process";
+import { lstat, readdir, readFile, realpath, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
+import { isPathWithinRoot } from "../domain/localPath.js";
+import { parseXmlPropertyList } from "../domain/propertyListKeys.js";
+import { err, ok } from "../domain/result.js";
+const execFileAsync = promisify(execFile);
+const BUNDLE_LAYOUTS = [
+    // macOS bundles keep both under Contents.
+    {
+        plist: ["Contents", "Info.plist"],
+        programs: ["Contents", "MacOS"],
+        programsLabel: "Contents/MacOS",
+    },
+    // iOS-style bundles, as extracted from an IPA, keep both at the root.
+    { plist: ["Info.plist"], programs: [], programsLabel: "the bundle root" },
+];
+/**
+ * Resolve an app bundle directory to its declared program file. macOS and
+ * flat iOS-style layouts are read directly. An iOS app installed on a Mac is
+ * a wrapper whose `Wrapper` directory holds the iOS bundle; that bundle is
+ * found by listing `Wrapper`, never by following the `WrappedBundle` link.
+ */
+export const resolveAppBundleExecutable = async (path) => {
+    const layout = await presentLayout(path);
+    if (layout !== undefined)
+        return resolveLayoutExecutable(path, layout);
+    const wrapped = await wrappedBundle(path);
+    if (wrapped !== undefined) {
+        const wrappedLayout = await presentLayout(wrapped);
+        if (wrappedLayout !== undefined)
+            return resolveLayoutExecutable(wrapped, wrappedLayout);
+    }
+    return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
+        cause: new Error("No Contents/Info.plist, root Info.plist, or single Wrapper/*.app bundle was found"),
+    }));
+};
+const presentLayout = async (bundle) => {
+    for (const layout of BUNDLE_LAYOUTS)
+        if (await layoutPlistPresent(join(bundle, ...layout.plist)))
+            return layout;
+    return undefined;
+};
+/**
+ * Whether a layout's Info.plist exists. Readable symlinks count, as they did
+ * when the plist was read directly; any failure other than absence, such as
+ * a permission denial, is left for the caller to report.
+ */
+const layoutPlistPresent = async (path) => {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch (cause) {
+        if (isAbsence(cause))
+            return false;
+        throw cause;
+    }
+};
+const isAbsence = (cause) => {
+    const code = cause instanceof Error ? Reflect.get(cause, "code") : undefined;
+    return code === "ENOENT" || code === "ENOTDIR";
+};
+/** The single real `.app` directory inside an iOS-on-Mac `Wrapper`. */
+const wrappedBundle = async (bundle) => {
+    const wrapper = join(bundle, "Wrapper");
+    try {
+        if (!(await lstat(wrapper)).isDirectory())
+            return undefined;
+    }
+    catch (cause) {
+        if (isAbsence(cause))
+            return undefined;
+        throw cause;
+    }
+    const apps = (await readdir(wrapper, { withFileTypes: true })).filter((entry) => entry.isDirectory() && entry.name.toLowerCase().endsWith(".app"));
+    const [app] = apps;
+    return apps.length === 1 && app !== undefined
+        ? join(wrapper, app.name)
+        : undefined;
+};
+const resolveLayoutExecutable = async (bundle, layout) => {
+    const plistPath = join(bundle, ...layout.plist);
+    let name;
+    try {
+        const plist = await readFile(plistPath);
+        name =
+            plist.subarray(0, 6).toString("ascii") === "bplist"
+                ? await readBinaryPlistExecutable(plistPath)
+                : parseXmlPlistExecutable(plist.toString("utf8"));
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(bundle, "app has no readable CFBundleExecutable", {
+            cause,
+        }));
+    }
+    if (!isSafeExecutableName(name))
+        return err(new BinaryTargetError(bundle, "app has an unsafe CFBundleExecutable"));
+    const programs = join(bundle, ...layout.programs);
+    const executable = join(programs, name);
+    try {
+        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
+            realpath(programs),
+            realpath(executable),
+        ]);
+        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
+            return err(new BinaryTargetError(bundle, `app program file leaves ${layout.programsLabel}`));
+        return ok({ executable: canonicalExecutable, infoPlist: plistPath });
+    }
+    catch (cause) {
+        return err(new BinaryTargetError(bundle, "app program file is missing", { cause }));
+    }
+};
+/** Decode the top-level executable name with an XML parser, not a pattern. */
+const parseXmlPlistExecutable = (plist) => {
+    // An unrelated `__proto__` entry must not make the bundle unreadable.
+    const { value } = parseXmlPropertyList(plist);
+    const executable = executableEntrySchema.safeParse(value);
+    if (!executable.success)
+        throw new Error("CFBundleExecutable is missing");
+    return executable.data.CFBundleExecutable;
+};
+const executableEntrySchema = z.looseObject({ CFBundleExecutable: z.string() });
+const readBinaryPlistExecutable = async (plistPath) => 
+// `-n` strips only the newline plutil appends; it requires macOS 12+.
+(await execFileAsync("/usr/bin/plutil", [
+    "-extract",
+    "CFBundleExecutable",
+    "raw",
+    "-n",
+    "-o",
+    "-",
+    plistPath,
+])).stdout;
+const isSafeExecutableName = (name) => name.length > 0 &&
+    name !== "." &&
+    name !== ".." &&
+    !name.includes("\0") &&
+    !/[/\\]/u.test(name);

package/dist/application/ArtifactInventory/classify.js

@@ -1,6 +1,6 @@
 import { open } from "node:fs/promises";
 import { classifyArtifactContent } from "../ArtifactGraphConstruction.js";
-import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "./hash.js";
+import { ARTIFACT_CLASSIFICATION_PREFIX_BYTES } from "../../artifacts/ArtifactHash.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();

package/dist/application/ArtifactInventory/scanCanonical.js

@@ -5,7 +5,7 @@ import { artifactInventoryResultSchema, } from "../../domain/artifactGraph.js";
 import { createArtifactEdges, createRootNode, indexOccurrencesByPath, materializeDirectoryNodes, rekeyOccurrences, rootOccurrenceFor, } from "../ArtifactGraphConstruction.js";
 import { canonicalDigest } from "../../domain/comparisonSemantics.js";
 import { classifyRoot } from "./classify.js";
-import { hashReadable } from "./hash.js";
+import { hashReadable } from "../../artifacts/ArtifactHash.js";
 import { createReader, inventoryLimitations } from "./reader.js";
 import { scanReader, } from "./scanReader.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";

package/dist/application/ArtifactInventory/scanReader.js

@@ -4,7 +4,7 @@ import { ArtifactReaderFailure, } from "../../artifacts/ArtifactReader.js";
 import { AsarArtifactReader } from "../../artifacts/AsarArtifactReader.js";
 import { classifyArtifactContent, createArtifactNode, createOccurrence, nearestParent, } from "../ArtifactGraphConstruction.js";
 import { STRICT_INTEGRITY_POLICY, } from "./types.js";
-import { hashReadable } from "./hash.js";
+import { hashReadable } from "../../artifacts/ArtifactHash.js";
 const UNAVAILABLE_UNPACKED_LIMITATION = "ASAR unpacked companion bytes were unavailable; no content hash or child artifact was produced.";
 const emptyScan = () => ({ nodes: new Map(), occurrences: [], pendingContradictions: [] });
 export const scanReader = async (reader, signal, integrity = STRICT_INTEGRITY_POLICY) => {

package/dist/application/ArtifactInventory.js

@@ -1,6 +1,6 @@
 import { realpath } from "node:fs/promises";
 import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { abortIfNeeded } from "./ArtifactInventory/hash.js";
+import { abortIfNeeded } from "../artifacts/ArtifactHash.js";
 import { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
 export { scanCanonicalArtifactInventory } from "./ArtifactInventory/scanCanonical.js";
 /** Inventory one local artifact and return every graph collection inline. */

package/dist/application/BinaryTargetResolver.js

@@ -1,17 +1,14 @@
 import { constants } from "node:fs";
 import { createHash } from "node:crypto";
-import { access, open, readFile, realpath, stat, } from "node:fs/promises";
-import { execFile } from "node:child_process";
-import { extname, isAbsolute, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import { isPathWithinRoot } from "../domain/localPath.js";
+import { access, open, realpath, stat, } from "node:fs/promises";
+import { extname, isAbsolute, resolve } from "node:path";
 import { BinaryTargetError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
+import { resolveAppBundleExecutable, } from "./AppBundleExecutable.js";
 import { validateDosComLength, } from "../domain/dosCom.js";
 import { mzWindowsHeaderOffset } from "../domain/dosMz.js";
 import { hasZipSignature, zipPackageFormatForPath, } from "../domain/zipPackageFormat.js";
 import { parseExecutableHeader, parsePeRecord, } from "../domain/binaryTarget.js";
-const execFileAsync = promisify(execFile);
 /**
  * Resolve and classify a readable local target before a provider is selected.
  * FAT Mach-O inputs select only a host-compatible architecture so setup remains
@@ -25,7 +22,8 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
         const resolved = await resolveAppBundle(canonical);
         if (!resolved.ok)
             return err(resolved.error);
-        const path = resolved.value;
+        const { executable: path, infoPlist } = resolved.value;
+        const bundle = infoPlist === undefined ? {} : { bundleInfoPlist: infoPlist };
         const handle = await open(path, "r");
         try {
             if (!(await handle.stat()).isFile())
@@ -72,6 +70,7 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
             return ok({
                 path,
                 sourcePath: process.platform === "win32" ? candidate : canonical,
+                ...bundle,
                 sha256: await sha256Handle(handle),
                 kind: "executable",
                 ...detected.value,
@@ -159,67 +158,13 @@ const sha256Handle = async (handle) => {
 const resolveAppBundle = async (path) => {
     const metadata = await stat(path);
     if (!metadata.isDirectory())
-        return ok(path);
+        return ok({ executable: path });
     if (extname(path).toLowerCase() !== ".app")
-        return err(new BinaryTargetError(path, "this opening route requires a file or macOS app bundle", {
+        return err(new BinaryTargetError(path, "this opening route requires a file or app bundle", {
             constraint: "directory_requires_file",
         }));
-    const plistPath = join(path, "Contents", "Info.plist");
-    let name;
-    try {
-        const plist = await readFile(plistPath);
-        name =
-            plist.subarray(0, 6).toString("ascii") === "bplist"
-                ? await readBinaryPlistExecutable(plistPath)
-                : parseXmlPlistExecutable(plist.toString("utf8"));
-    }
-    catch (cause) {
-        return err(new BinaryTargetError(path, "app has no readable CFBundleExecutable", {
-            cause,
-        }));
-    }
-    if (!isSafeExecutableName(name))
-        return err(new BinaryTargetError(path, "app has an unsafe CFBundleExecutable"));
-    const programs = join(path, "Contents", "MacOS");
-    const executable = join(programs, name);
-    try {
-        const [canonicalPrograms, canonicalExecutable] = await Promise.all([
-            realpath(programs),
-            realpath(executable),
-        ]);
-        if (!isPathWithinRoot(canonicalPrograms, canonicalExecutable))
-            return err(new BinaryTargetError(path, "app program file leaves Contents/MacOS"));
-        return ok(canonicalExecutable);
-    }
-    catch (cause) {
-        return err(new BinaryTargetError(path, "app program file is missing", { cause }));
-    }
-};
-const parseXmlPlistExecutable = (plist) => {
-    const match = /<key>\s*CFBundleExecutable\s*<\/key>\s*<string>([^<]+)<\/string>/u.exec(plist);
-    if (match?.[1] === undefined)
-        throw new Error("CFBundleExecutable is missing");
-    return decodeXml(match[1].trim());
+    return resolveAppBundleExecutable(path);
 };
-const readBinaryPlistExecutable = async (plistPath) => (await execFileAsync("/usr/bin/plutil", [
-    "-extract",
-    "CFBundleExecutable",
-    "raw",
-    "-o",
-    "-",
-    plistPath,
-])).stdout.trim();
-const isSafeExecutableName = (name) => name.length > 0 &&
-    name !== "." &&
-    name !== ".." &&
-    !name.includes("\0") &&
-    !/[/\\]/u.test(name);
-const decodeXml = (value) => value
-    .replaceAll("&amp;", "&")
-    .replaceAll("&lt;", "<")
-    .replaceAll("&gt;", ">")
-    .replaceAll("&quot;", '"')
-    .replaceAll("&apos;", "'");
 const readExecutableMetadata = async (handle, hostArchitecture) => {
     const prefix = Buffer.alloc(4096);
     const prefixRead = await handle.read(prefix, 0, prefix.length, 0);