rea-agents 3.2.1 → 4.0.0

package/dist/hopper/HopperProvider.js

@@ -24,7 +24,10 @@ const MUTATING_OPERATIONS = new Set([
 ]);
 /** Tool contracts implemented directly by the Hopper adapter. */
 export const HOPPER_PROVIDER_TOOL_CONTRACTS = Object.freeze([
-    ...GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy"),
+    ...GENERATED_MCP_TOOL_CATALOG.filter(({ kind, name }) => kind === "official-proxy" &&
+        name !== "inspect_native_data_type" &&
+        name !== "inspect_native_instruction" &&
+        name !== "resolve_native_call_targets"),
     ...GENERATED_MCP_TOOL_CATALOG.filter(({ name }) => name === "analyze_function"),
 ]);
 const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract) => {
@@ -54,9 +57,17 @@ const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract)
 export class HopperProvider {
     config;
     logger;
-    constructor(config, logger) {
+    platform;
+    /**
+     * Host platform, injected so availability and launch-mode decisions can be
+     * exercised for any host rather than only the machine running the suite.
+     * Mirrors `GhidraProvider`, which already threads its installation host's
+     * platform the same way.
+     */
+    constructor(config, logger, platform = process.platform) {
         this.config = config;
         this.logger = logger;
+        this.platform = platform;
     }
     identity() {
         return IDENTITY;
@@ -67,13 +78,13 @@ export class HopperProvider {
     inspectAvailability() {
         const diagnostics = {
             launcher_path: this.config.hopperLauncherPath,
-            platform: process.platform,
+            platform: this.platform,
         };
-        if (process.platform !== "darwin" && process.platform !== "linux")
+        if (this.platform !== "darwin" && this.platform !== "linux")
             return {
                 status: "unavailable",
                 code: "unsupported_host",
-                reason: `Hopper integration is not supported on ${process.platform}.`,
+                reason: `Hopper integration is not supported on ${this.platform}.`,
                 diagnostics,
             };
         try {
@@ -114,6 +125,13 @@ export class HopperProvider {
                 reason: null,
                 diagnostics,
             };
+        if (target.format === "dos-mz")
+            return {
+                status: "unsupported",
+                code: "target_format_unsupported",
+                reason: "DOS MZ analysis requires the Ghidra 16-bit real-mode adapter.",
+                diagnostics,
+            };
         return {
             status: "supported",
             code: null,
@@ -151,7 +169,7 @@ export class HopperProvider {
                     ? this.config.hopperLoaderArgs
                     : derivedLoaderArgs.value,
                 bridgeScriptPath: fileURLToPath(new URL("../../bridge/hopper_bridge.py", import.meta.url)),
-                ...(process.platform === "linux"
+                ...(this.platform === "linux"
                     ? {
                         launchMode: "verified_linux_demo",
                         demoHelperPath: fileURLToPath(new URL("../../scripts/hopper-demo-x11.py", import.meta.url)),
@@ -172,6 +190,11 @@ export class HopperProvider {
                             ...(profile === undefined ? {} : { analysisProfile: profile }),
                             limitations: [
                                 "Results depend on Hopper's completed static analysis.",
+                                ...(operation === "procedure_references"
+                                    ? [
+                                        "Hopper's public Python API does not expose flow classification for calls without resolved targets; unresolved_calls is empty and its coverage is unknown.",
+                                    ]
+                                    : []),
                             ],
                         }),
                     }

package/dist/hopper/HopperTargetLease.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { chmod, lstat, mkdir, realpath, rm } from "node:fs/promises";
 import { createConnection, createServer, } from "node:net";
 import { join, resolve } from "node:path";
+import { HopperStartError } from "../domain/errors.js";
 const leaseDirectory = join("/tmp", `rea-hopper-${process.getuid?.() ?? 0}`);
 /** Keep two REA processes from opening duplicate Hopper documents for one target/profile. */
 export const acquireHopperTargetLease = async (input) => {
@@ -42,15 +43,28 @@ export const acquireHopperTargetLease = async (input) => {
             return { acquired: false, owner: existingOwner };
         await rm(socketPath, { force: true });
     }
-    throw new Error("Could not acquire the Hopper target lease");
+    throw new HopperStartError({
+        userMessage: "REA could not reserve this Hopper target. Close competing REA sessions and retry.",
+    });
 };
 const ensureLeaseDirectory = async (directory) => {
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    const directoryStat = await lstat(directory);
+    let directoryStat;
+    try {
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        directoryStat = await lstat(directory);
+    }
+    catch (cause) {
+        throw new HopperStartError({
+            cause,
+            userMessage: "REA could not create or inspect its private Hopper lease directory.",
+        });
+    }
     if (directoryStat.isSymbolicLink() ||
         directoryStat.isDirectory() === false ||
         (process.getuid !== undefined && directoryStat.uid !== process.getuid()))
-        throw new Error("Hopper target lease directory is not private");
+        throw new HopperStartError({
+            userMessage: "REA's Hopper lease directory is not a private directory owned by this user.",
+        });
     if ((directoryStat.mode & 0o077) !== 0)
         await chmod(directory, 0o700);
 };

package/dist/logger.js

@@ -9,19 +9,6 @@ export const parseLogLevel = (value) => logLevelSchema.parse(value);
 export const createLogger = (mode, level) => pino({
     level,
     base: { application: "rea", mode },
-    redact: {
-        paths: [
-            "token",
-            "*.token",
-            "params",
-            "*.params",
-            "arguments",
-            "*.arguments",
-            "environment",
-            "*.environment",
-        ],
-        censor: "[Redacted]",
-    },
 }, pino.destination({ dest: 2, sync: false }));
 /** Logger used by embedders that have not opted into process output. */
 export const silentLogger = pino({ level: "silent" });

package/dist/main/messages.js

@@ -1,5 +1,4 @@
 export const MCP_CONNECTION_LOST = "REA lost its MCP client connection. Restart REA from your MCP client.";
 export const MCP_CONNECTION_START_FAILED = "REA could not start its MCP connection. Restart REA from your MCP client; run `rea doctor` if it fails again.";
 export const MCP_SHUTDOWN_FAILED = "REA could not close cleanly. End the REA process before starting it again.";
-export const MCP_PERMISSION_RELOAD_FAILED = "Reloaded permission policy failed unexpectedly";
 export const SERVER_START_FAILED = "REA could not start. Run `rea doctor`, then restart REA from your MCP client.";

package/dist/main/reload.js

@@ -1,41 +1,12 @@
 import { parseConfig } from "../config.js";
-import { readProjectPermissionStore } from "../application/ProjectPermissionStore.js";
-import { MCP_PERMISSION_RELOAD_FAILED } from "./messages.js";
 export const registerConfigReload = (input) => {
-    const { dependencies, permissionAuthority, runtimeState, serverLogger } = input;
-    let reloadQueue = Promise.resolve();
+    const { dependencies, runtimeState, serverLogger } = input;
     return (dependencies.registerReload?.(() => {
         const refreshed = parseConfig(dependencies.env);
         if (!refreshed.ok) {
-            serverLogger.error("Reloaded permission policy is invalid");
+            serverLogger.error("Reloaded REA configuration is invalid");
             return;
         }
-        reloadQueue = reloadQueue
-            .then(async () => {
-            let projectGrants = [];
-            if (refreshed.value.permissionProjectRoot !== undefined &&
-                refreshed.value.permissionProjectStore !== undefined) {
-                const project = await (dependencies.readProjectPermissionStore ??
-                    readProjectPermissionStore)(refreshed.value.permissionProjectStore, refreshed.value.permissionProjectRoot);
-                if (!project.ok) {
-                    serverLogger.error("Reloaded project grants could not be read");
-                    return;
-                }
-                projectGrants = project.value?.grants ?? [];
-            }
-            const reloaded = await permissionAuthority.replaceConfiguredPolicy({
-                ceilings: refreshed.value.permissionCeilings,
-                administratorGrants: refreshed.value.administratorPermissionGrants,
-                projectGrants,
-            });
-            if (!reloaded.ok) {
-                serverLogger.error("Reloaded permission policy could not be applied");
-                return;
-            }
-            runtimeState.currentConfig = refreshed.value;
-        })
-            .catch(() => {
-            serverLogger.error(MCP_PERMISSION_RELOAD_FAILED);
-        });
+        runtimeState.currentConfig = refreshed.value;
     }) ?? (() => undefined));
 };

package/dist/main/shutdown.js

@@ -1,6 +1,6 @@
 import { MCP_SHUTDOWN_FAILED } from "./messages.js";
 export const createShutdown = (input) => {
-    const { handle, session, permissionAuthority, unregisterReload, dependencies, serverLogger, } = input;
+    const { handle, session, unregisterReload, dependencies, serverLogger } = input;
     let shutdownPromise;
     let unregisterShutdown = () => undefined;
     const shutdown = async () => {
@@ -9,7 +9,6 @@ export const createShutdown = (input) => {
             unregisterShutdown();
             await handle.close();
             await session.close({ retainProviderDocuments: true });
-            permissionAuthority.clearSessionGrants();
         })();
         return shutdownPromise;
     };

package/dist/main/transport.js

@@ -13,14 +13,7 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     try {
         handle = dependencies.serve(() => (dependencies.createServer ?? createServer)(session, session, {
             logger: serverContext.logger,
-            processPolicy: () => serverContext.runtimeState.currentConfig.processExecutionPolicy,
-            permissionAuthority: serverContext.permissionAuthority,
             ...optionalProviders,
-            artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
-                .artifactIntegrityContinueEnabled,
-            javascriptReplayPolicy: () => serverContext.runtimeState.currentConfig.javascriptReplayPolicy,
-            managedRuntimePolicy: () => serverContext.runtimeState.currentConfig.managedRuntimePolicy,
-            availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
         }), {
             onerror: () => {
                 serverLogger.error(MCP_CONNECTION_LOST);
@@ -36,13 +29,3 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     }
     return { ok: true, handle };
 };
-const runtimeAvailability = (state) => ({
-    processCaptureEnabled: state.currentConfig.processExecutionPolicy.status === "enabled",
-    browserObservationEnabled: state.currentConfig.browserObservationPolicy.status === "enabled",
-    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.status === "enabled",
-    electronObservationEnabled: state.currentConfig.electronObservationPolicy.status === "enabled",
-    electronAutomationEnabled: state.currentConfig.electronAutomationPolicy.status === "enabled",
-    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationPolicy.status === "enabled",
-    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.status === "enabled",
-    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.status === "enabled",
-});

package/dist/main.js

@@ -6,7 +6,6 @@ import { parseConfig } from "./config.js";
 import { createBinarySession } from "./application/runtime.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/errors.js";
-import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
 import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
@@ -50,11 +49,6 @@ export const run = async (dependencies = runtimeDependencies()) => {
     }
     const logger = createLogger("mcp", config.value.logLevel);
     const serverLogger = logger.child({ layer: "server" });
-    const permissionAuthority = await loadConfiguredPermissionAuthority(config.value);
-    if (!permissionAuthority.ok) {
-        dependencies.writeStderr(`${projectAnalysisError(permissionAuthority.error).message}\n`);
-        return 1;
-    }
     const session = createBinarySession(config.value, logger);
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
@@ -80,21 +74,17 @@ export const run = async (dependencies = runtimeDependencies()) => {
                     javascriptRuntimeObservation: new V8InspectorProvider(),
                 };
             }),
-        permissionAuthority: permissionAuthority.value,
-        runtimeState,
     });
     if (!transport.ok)
         return 1;
     const unregisterReload = registerConfigReload({
         dependencies,
-        permissionAuthority: permissionAuthority.value,
         runtimeState,
         serverLogger,
     });
     createShutdown({
         handle: transport.handle,
         session,
-        permissionAuthority: permissionAuthority.value,
         unregisterReload,
         dependencies,
         serverLogger,