rea-agents 6.1.0 → 6.2.0

package/dist/application/CapabilityInventory.js

@@ -37,6 +37,21 @@ const ENHANCED_REQUIREMENTS = {
         "resolve_containing_procedure",
     ],
 };
+/** Contract kinds whose operations run on the active session target. */
+const ACTIVE_TARGET_KINDS = new Set([
+    "official-proxy",
+    "enhanced",
+    "native-provider",
+    "artifact-provider",
+]);
+/** Native contracts defined only for an active Mach-O executable. */
+const MACHO_TARGET_OPERATIONS = new Set([
+    "inspect_macho",
+    "list_architectures",
+    "observe_native_calls",
+    "observe_native_ui",
+    "capture_native_ui_scenario",
+]);
 const NAVIGATION_CONTEXT_MODES = [
     {
         name: "current_selection",
@@ -61,6 +76,7 @@ export const buildCapabilityInventory = (sessionStatus, policy, clientFeatures =
             kind: contract.kind,
             targetOpen: status.open,
             targetKind: status.kind,
+            targetFormat: status.format,
             descriptors,
             policy,
         });
@@ -125,6 +141,9 @@ const availabilityFor = (context) => {
     const workflowAvailability = workflowAvailabilityFor(context);
     if (workflowAvailability !== null)
         return workflowAvailability;
+    const hostDecision = hostAvailability(context);
+    if (hostDecision !== null)
+        return hostDecision;
     const targetDecision = targetAvailability(context);
     if (targetDecision !== null)
         return targetDecision;
@@ -226,7 +245,7 @@ const workflowAvailabilityFor = ({ name, kind, policy, }) => {
                     ? "unsupported_host"
                     : "provider_missing",
                 remediation: policy.androidAnalysisAvailability?.reason ??
-                    "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide a full JDK on Linux or macOS.",
+                    "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide a full JDK on Linux, macOS, or Windows x64 with its matching bundled native controls.",
             };
     const browser = browserProviderAvailability(name, kind, policy);
     if (browser !== null)
@@ -286,8 +305,22 @@ const browserProviderAvailability = (name, kind, policy) => {
             remediation: "Start REA with its browser observation provider available.",
         };
 };
-const targetAvailability = ({ kind, targetKind, targetOpen, }) => {
-    if (!targetOpen && (kind === "official-proxy" || kind === "enhanced"))
+/**
+ * Opening another target cannot make an operation run on an unsupported host.
+ * Composed operations are decided by their requirements, which another
+ * provider may satisfy.
+ */
+const hostAvailability = ({ descriptors, kind, name, }) => {
+    if (kind === "enhanced")
+        return null;
+    const descriptor = descriptors.get(name);
+    return descriptor?.available === false &&
+        descriptor.availability_code === "unsupported_host"
+        ? { reason: "unsupported_host", remediation: descriptor.reason }
+        : null;
+};
+const targetAvailability = ({ name, kind, targetKind, targetFormat, targetOpen, }) => {
+    if (!targetOpen && ACTIVE_TARGET_KINDS.has(kind))
         return {
             reason: "target_required",
             remediation: "Call open_binary with a supported local target.",
@@ -300,6 +333,13 @@ const targetAvailability = ({ kind, targetKind, targetOpen, }) => {
             reason: "target_unsupported",
             remediation: "Inventory or extract a native executable, then call open_binary on that executable.",
         };
+    if (targetOpen &&
+        MACHO_TARGET_OPERATIONS.has(name) &&
+        (targetKind !== "executable" || targetFormat !== "mach-o"))
+        return {
+            reason: "target_unsupported",
+            remediation: "Call open_binary with a Mach-O executable or an app bundle whose main executable is Mach-O.",
+        };
     return null;
 };
 const providerAvailability = ({ descriptors, kind, name, }) => {
@@ -316,12 +356,6 @@ const providerAvailability = ({ descriptors, kind, name, }) => {
             reason: "provider_missing",
             remediation: "Install or configure a provider that declares this operation.",
         };
-    if (!descriptor.available &&
-        descriptor.availability_code === "unsupported_host")
-        return {
-            reason: "unsupported_host",
-            remediation: descriptor.reason,
-        };
     return descriptor.available
         ? { reason: "available", remediation: null }
         : {

package/dist/application/ClientConfigurationDocument.js

@@ -302,7 +302,7 @@ const isBlankOrComment = (line) => {
 };
 const looksLikeTomlHeader = (line) => line.trimStart().startsWith("[");
 /** `mcp_servers.<server>` and tables nested under it, compared by key segment. */
-const isGrokServerTable = (path, serverKey) => path[0] === "mcp_servers" && path[1] === serverKey;
+const isTomlServerTable = (path, serverKey) => path[0] === "mcp_servers" && path[1] === serverKey;
 const parseKeyPath = (text, start) => {
     const segments = [];
     let index = start;
@@ -486,7 +486,7 @@ const hasSeparatorComma = (trivia) => trivia.split("\n").some((part) => {
  * Replace or remove `serverKey` inside one `{ ... }` table. A closed inline
  * table cannot later grow a `[mcp_servers.rea]` header.
  */
-const editGrokInlineTable = (table, serverKey, entry) => {
+const editInlineServerTable = (table, serverKey, entry) => {
     if (!table.startsWith("{"))
         return undefined;
     const end = endOfContainer(table, 0);
@@ -667,10 +667,12 @@ const disabledServerListLines = (edit, lines, lineIndex, endLine) => {
     }
 };
 /**
- * Replace REA's Grok server tables and assignments. Comments that introduce a
- * following table stay. Text inside strings is not treated as a header.
+ * Replace REA's TOML server tables and assignments. Comments that introduce a
+ * following table stay. Codex also retains comments around REA's own table.
+ * Text inside strings is not treated as a header. Only Grok Build reads the
+ * root `disabled_mcp_servers` list that registration also edits.
  */
-const upsertGrokServerSection = (originalText, serverKey, entry) => {
+const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     // smol-toml accepts a leading BOM. Leave it in place or the first header is missed.
     const bom = originalText.startsWith("\uFEFF");
     const source = bom ? originalText.slice(1) : originalText;
@@ -721,7 +723,7 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
         const header = parseTomlTableHeader(line);
         if (header !== undefined) {
             tablePath = header.path;
-            if (isGrokServerTable(header.path, serverKey)) {
+            if (isTomlServerTable(header.path, serverKey)) {
                 discardPending();
                 skipping = true;
                 lineIndex += 1;
@@ -748,17 +750,19 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
                 mode = "none";
                 continue;
             }
-            const disabledLines = disabledServerListLines(disabledServerListEdit({
-                text,
-                lineStart,
-                valueOffset,
-                valueEnd,
-                statementEnd,
-                tablePath,
-                segments: assignment.segments,
-                serverKey,
-                entry,
-            }), lines, lineIndex, endLine);
+            const disabledLines = format === "grok"
+                ? disabledServerListLines(disabledServerListEdit({
+                    text,
+                    lineStart,
+                    valueOffset,
+                    valueEnd,
+                    statementEnd,
+                    tablePath,
+                    segments: assignment.segments,
+                    serverKey,
+                    entry,
+                }), lines, lineIndex, endLine)
+                : undefined;
             if (disabledLines !== undefined) {
                 flushPending();
                 kept.push(...disabledLines);
@@ -771,10 +775,10 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
             const closesServerTable = absolute.length === 1 &&
                 absolute[0] === "mcp_servers" &&
                 text[open] === "{";
-            if (closesServerTable || isGrokServerTable(absolute, serverKey)) {
+            if (closesServerTable || isTomlServerTable(absolute, serverKey)) {
                 if (closesServerTable) {
                     flushPending();
-                    const edited = editGrokInlineTable(text.slice(open, valueEnd), serverKey, entry);
+                    const edited = editInlineServerTable(text.slice(open, valueEnd), serverKey, entry);
                     const prefix = text.slice(lineStart, open);
                     const suffix = text.slice(valueEnd, statementEnd);
                     const replacement = edited === undefined
@@ -796,7 +800,12 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
             continue;
         }
         if (isBlankOrComment(line)) {
-            pending.push(physical);
+            if (format === "toml" && line.trimStart().startsWith("#")) {
+                flushPending();
+                kept.push(physical);
+            }
+            else
+                pending.push(physical);
             lineIndex += 1;
             continue;
         }
@@ -840,7 +849,7 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
     }
     return bom ? `\uFEFF${body}` : body;
 };
-const grokServerEntry = (document, serverKey) => {
+const tomlServerEntry = (document, serverKey) => {
     const servers = objectSchema.safeParse(document.mcp_servers);
     if (!servers.success || !Object.hasOwn(servers.data, serverKey))
         return undefined;
@@ -851,10 +860,45 @@ export const grokServerListedDisabled = (document, serverKey) => Array.isArray(d
     document.disabled_mcp_servers.includes(serverKey);
 /** Keep an existing Grok document intact aside from the REA server tables. */
 const serializeGrokConfiguration = (document, originalText) => {
-    const entry = grokServerEntry(document, PRODUCT_IDENTITY.mcpServerKey);
+    const entry = tomlServerEntry(document, PRODUCT_IDENTITY.mcpServerKey);
     if (originalText === undefined)
         return stringifyToml(document);
-    return upsertGrokServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, entry);
+    return upsertTomlServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, entry, "grok");
+};
+/** Removing the last server leaves an empty table, which equals an absent one. */
+const withoutEmptyServerTable = (document) => {
+    const servers = objectSchema.safeParse(document.mcp_servers);
+    if (!servers.success || Object.keys(servers.data).length > 0)
+        return document;
+    const { mcp_servers: empty, ...rest } = document;
+    void empty;
+    return rest;
+};
+/**
+ * Keep an existing Codex document intact aside from the REA server tables.
+ * An edit that would change any other parsed value falls back to a full
+ * rewrite, which keeps every value but not comments or spelling.
+ */
+const serializeCodexConfiguration = (document, originalText) => {
+    if (originalText === undefined ||
+        isEmptyClientConfigurationText(originalText))
+        return stringifyToml(document);
+    const upserted = upsertTomlServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, tomlServerEntry(document, PRODUCT_IDENTITY.mcpServerKey), "toml");
+    // Removing a final table also drops the file's last line break.
+    const edited = originalText.endsWith("\n") && !upserted.endsWith("\n")
+        ? `${upserted}${originalText.endsWith("\r\n") ? "\r\n" : "\n"}`
+        : upserted;
+    return tomlTextHolds(edited, document) ? edited : stringifyToml(document);
+};
+const tomlTextHolds = (text, document) => {
+    try {
+        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseToml(text))), withoutEmptyServerTable(document));
+    }
+    catch (cause) {
+        // An unparsable edit is rejected in favor of the full rewrite.
+        void cause;
+        return false;
+    }
 };
 /** Comments in the trivia between two properties. `undefined` when there are none. */
 const commentsBetweenProperties = (gap) => {
@@ -952,12 +996,12 @@ const deleteJsonPropertyPreservingComments = (text, path) => {
         suffix += "\n";
     return `${text.slice(0, previous.offset + previous.length)}${suffix}${remainder}`;
 };
-/** Serialize a validated client document, retaining JSONC comments. */
+/** Serialize a validated client document, retaining JSONC and TOML comments. */
 export const serializeClientConfiguration = (document, format, originalText, editedPaths) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
     if (format === "toml")
-        return stringifyToml(document);
+        return serializeCodexConfiguration(document, originalText);
     if (format === "grok")
         return serializeGrokConfiguration(document, originalText);
     // An empty original holds no comments or settings to preserve. Writing a

package/dist/application/DirectAnalysis.js

@@ -1,4 +1,3 @@
-import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { executeFunctionAnalysisEvidence } from "./FunctionAnalysisEvidence.js";
 import { silentLogger } from "../logger.js";
@@ -15,6 +14,9 @@ import { err, ok } from "../domain/result.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "./WorkflowEvidence.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
+import { resolveXrefsAddress } from "./XrefsAddressResolution.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { directAnalysisCleanupFailure, managedAnalysisCleanupFailure, withSessionCleanup, } from "./DirectAnalysisCleanup.js";
 /**
  * Open one binary, execute one tool, and always release provider resources.
  * Unlike MCP mode, every CLI invocation is intentionally isolated and does not
@@ -42,15 +44,12 @@ export const runProviderAnalysis = async (dependencies, ...[path, tool, argument
 /** Execute managed metadata inspection in an isolated managed-only session. */
 export const runManagedProviderExecution = async (dependencies, path, tool, signal) => withProcessCancellation(signal, async (operationSignal) => {
     const session = dependencies.createManagedBinarySession();
-    try {
+    return withSessionCleanup(session, async () => {
         const opened = await session.open(path, { signal: operationSignal });
         if (!opened.ok)
             return opened;
         return await session.execute(tool, {}, { signal: operationSignal });
-    }
-    finally {
-        await session.close();
-    }
+    }, managedAnalysisCleanupFailure);
 });
 const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
     const execution = await runManagedProviderExecution(dependencies, path, tool, signal);
@@ -68,11 +67,11 @@ const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
 };
 const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
-    const config = parseConfig(options.environment ?? process.env);
+    const config = dependencies.readConfiguration();
     if (!config.ok)
         return cliError(config.error);
     const session = dependencies.createBinarySession(config.value, logger);
-    try {
+    return withSessionCleanup(session, async () => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
@@ -180,10 +179,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
                 return cliError(written.error);
         }
         return output;
-    }
-    finally {
-        await session.close();
-    }
+    }, directAnalysisCleanupFailure);
 };
 const executeAnalysisTool = async (input) => {
     const { session, tool, signal, evidenceProfile } = input;
@@ -211,7 +207,22 @@ const executeAnalysisTool = async (input) => {
         });
         return { output: evidence, evidence };
     }
-    const result = await session.execute(tool, input.arguments, { signal });
+    let result = await session.execute(tool, input.arguments, { signal });
+    if (tool === "xrefs" &&
+        typeof input.arguments.address === "string" &&
+        !result.ok &&
+        result.error instanceof AnalysisInputError &&
+        !result.error.cleanupIncomplete &&
+        result.error.issues.length > 0 &&
+        result.error.issues.every(({ path, reason }) => path.length === 1 &&
+            path[0] === "address" &&
+            reason === "invalid_format")) {
+        const address = await resolveXrefsAddress(session, input.arguments.address, signal);
+        if (!address.ok)
+            return { output: cliError(address.error) };
+        if (address.value !== input.arguments.address)
+            result = await session.execute(tool, { ...input.arguments, address: address.value }, { signal });
+    }
     if (!result.ok)
         return { output: cliError(result.error) };
     const evidence = createEvidence(result.value.subject ?? input.openedTarget, result.value.provider, {
@@ -236,12 +247,16 @@ const withProcessCancellation = async (suppliedSignal, operation) => {
         return operation(suppliedSignal);
     const controller = new AbortController();
     const cancel = () => controller.abort();
-    process.once("SIGINT", cancel);
+    // Package runners can forward a terminal interrupt after REA already received
+    // it directly. Keep both guards installed until provider cleanup has settled.
+    process.on("SIGINT", cancel);
+    process.on("SIGTERM", cancel);
     try {
         return await operation(controller.signal);
     }
     finally {
         process.off("SIGINT", cancel);
+        process.off("SIGTERM", cancel);
     }
 };
 const prepareSnapshot = async (options) => {

package/dist/application/DirectAnalysisCleanup.js

@@ -0,0 +1,72 @@
+import { analysisErrorProjectionSchema } from "../contracts/errorSchemas.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { err } from "../domain/result.js";
+import { analysisErrorWithCleanupFailure } from "./binary/AnalysisClientCleanup.js";
+/** Await one-shot cleanup and retain either the outcome or both failures. */
+export const withSessionCleanup = async (session, operation, onCleanupFailure) => {
+    let value;
+    try {
+        value = await operation();
+    }
+    catch (cause) {
+        const closed = await session.close();
+        if (!closed.ok)
+            throw new AggregateError([cause, closed.error], "Analysis and provider cleanup both failed", { cause });
+        throw cause;
+    }
+    const closed = await session.close();
+    return closed.ok ? value : onCleanupFailure(value, closed.error);
+};
+/** Keep the primary CLI failure or completed Evidence alongside cleanup failure. */
+export const directAnalysisCleanupFailure = (output, error) => {
+    const cleanup = projectAnalysisError(error);
+    if (typeof output === "object" && output !== null && !Array.isArray(output)) {
+        const { error: label, ...projection } = output;
+        const primary = analysisErrorProjectionSchema.safeParse(projection);
+        if (typeof label === "string" && primary.success)
+            return {
+                error: label,
+                ...primary.data,
+                code: "cleanup_incomplete",
+                retryable: false,
+                details: {
+                    ...primary.data.details,
+                    cleanup: "incomplete",
+                    resources: error.cleanupResources.slice(),
+                    execution_failure: primary.data.details !== undefined &&
+                        "execution_failure" in primary.data.details
+                        ? (primary.data.details.execution_failure ?? primary.data.code)
+                        : primary.data.code,
+                    primary_error: projection,
+                    cleanup_error: cleanup,
+                },
+            };
+    }
+    return {
+        error: "Analysis failed",
+        ...cleanup,
+        code: "cleanup_incomplete",
+        retryable: false,
+        details: {
+            ...cleanup.details,
+            cleanup: "incomplete",
+            partial_observation: output,
+        },
+    };
+};
+/** Preserve managed observations or the original typed failure in diagnostics. */
+export const managedAnalysisCleanupFailure = (result, error) => {
+    if (!result.ok)
+        return err(analysisErrorWithCleanupFailure(result.error, error));
+    const cleanup = projectAnalysisError(error);
+    return err(new ProviderAdapterError(error instanceof ProviderAdapterError ? error.providerId : "rea", "close_binary", {
+        cause: error,
+        cleanup: { reason: cleanup.message, resources: error.cleanupResources },
+        diagnostics: {
+            cleanup_error: cleanup,
+            partial_observation: jsonValueSchema.parse(result.value),
+        },
+    }));
+};

package/dist/application/DirectAnalysisStatus.js

@@ -1,10 +1,9 @@
-import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
-const runSessionStatus = async (dependencies, logger = silentLogger, environment = process.env) => {
-    const config = parseConfig(environment);
+const runSessionStatus = async (dependencies, logger = silentLogger) => {
+    const config = dependencies.readConfiguration();
     if (!config.ok)
         return { error: projectAnalysisError(config.error) };
     const session = dependencies.createBinarySession(config.value, logger);
@@ -21,6 +20,6 @@ const runSessionStatus = async (dependencies, logger = silentLogger, environment
     }
 };
 /** List binary-session provider candidates and auxiliary operation availability. */
-export const runProviderStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);
+export const runProviderStatus = (dependencies, logger = silentLogger) => runSessionStatus(dependencies, logger);
 /** List binary-session operation descriptors; this is not the full MCP catalog. */
-export const runCapabilityStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);
+export const runCapabilityStatus = (dependencies, logger = silentLogger) => runSessionStatus(dependencies, logger);

package/dist/application/Doctor.js

@@ -1,11 +1,11 @@
 import { constants } from "node:fs";
 import { access, readFile, readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { delimiter, join } from "node:path";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
+import { join } from "node:path";
 import { analysisErrorRemediationAction } from "../domain/analysisErrorPresentation.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
-import { probeHomebrew } from "./homebrew.js";
+import { installedCaskAppdir, probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
 import { canonicalSkillNeedsInstall } from "./SetupSkill.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
@@ -115,23 +115,13 @@ const registrationCheck = (registration) => ({
     remediation: registration.remediation,
 });
 const installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
-const homeFromEnvironment = (environment, platform) => {
-    const selected = platform === "win32"
-        ? (environment.USERPROFILE ??
-            (environment.HOMEDRIVE !== undefined &&
-                environment.HOMEPATH !== undefined
-                ? `${environment.HOMEDRIVE}${environment.HOMEPATH}`
-                : environment.HOME))
-        : (environment.HOME ?? environment.USERPROFILE);
-    return selected ?? homedir();
-};
 /** Create diagnostics backed by the current process and host commands. */
 export const systemDoctorHost = (options = {}) => {
     const platform = options.platform ?? process.platform;
     const architecture = options.architecture ?? process.arch;
     const environment = options.environment ?? process.env;
     const hostExecFileOutput = options.execFileOutput ?? execFileOutput;
-    const homeDirectory = homeFromEnvironment(environment, platform);
+    const homeDirectory = homeDirectoryFromEnvironment(environment, platform);
     const commandEnvironment = { env: environment };
     return {
         platform,
@@ -180,15 +170,21 @@ export const systemDoctorHost = (options = {}) => {
         supportedLinuxHopper: linuxHopperBinarySupported,
         async brewHopperPath() {
             return probeHomebrew(async (command) => {
+                let caskroom;
                 try {
-                    const prefix = (await hostExecFileOutput(command, ["--prefix", "--cask", "hopper-disassembler"], commandEnvironment)).stdout.trim();
-                    return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
+                    // Without a cask argument, `--caskroom` does not load Homebrew's
+                    // cask API, so doctor writes no Homebrew cache files.
+                    caskroom = (await hostExecFileOutput(command, ["--caskroom"], commandEnvironment)).stdout.trim();
                 }
                 catch (cause) {
                     // best-effort cleanup: optional Homebrew probing; absence means uninstalled.
                     void cause;
                     return undefined;
                 }
+                const appdir = await installedCaskAppdir(caskroom, "hopper-disassembler", homeDirectory);
+                return appdir === undefined
+                    ? undefined
+                    : join(appdir, "Hopper Disassembler.app/Contents/MacOS/hopper");
             });
         },
         manualHopperPaths: () => manualHopperPaths(homeDirectory),
@@ -229,7 +225,7 @@ export const systemDoctorHost = (options = {}) => {
         }),
     };
 };
-const readMacosVersion = async (run = execFileOutput, options = { env: process.env }) => {
+const readMacosVersion = async (run, options) => {
     try {
         return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
     }
@@ -239,7 +235,7 @@ const readMacosVersion = async (run = execFileOutput, options = { env: process.e
         return undefined;
     }
 };
-const executableAvailable = async (path, platform = process.platform, run = execFileOutput, options = { env: process.env }) => {
+const executableAvailable = async (path, platform, run, options) => {
     try {
         await access(path, constants.X_OK);
         if (platform !== "linux")
@@ -260,7 +256,7 @@ const uncomposedLinuxDemoRuntimeCheck = () => Promise.resolve({
     detail: "Linux Hopper private-display diagnostics were not composed",
     remediation: "Run rea doctor through the production CLI adapter.",
 });
-const manualHopperPaths = async (home = homedir()) => {
+const manualHopperPaths = async (home) => {
     const paths = [];
     for (const root of ["/Applications", join(home, "Applications")]) {
         try {

package/dist/application/DoctorDiagnostics.js

@@ -1,4 +1,3 @@
-import { homedir } from "node:os";
 import { SUPPORTED_NODE_VERSION_PROSE, supportsNodeVersion, } from "../domain/runtimeVersion.js";
 import { linuxHopperLauncherPath } from "./LinuxHopper.js";
 const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
@@ -75,7 +74,7 @@ const findHopper = async (host) => {
         ? [
             DEFAULT_HOPPER,
             SYSTEM_LINUX_HOPPER,
-            linuxHopperLauncherPath(host.homeDirectory ?? homedir()),
+            linuxHopperLauncherPath(host.homeDirectory),
             ...(await host.manualHopperPaths()),
         ]
         : [host.configuredHopperPath];