rea-agents 6.1.0 → 6.3.0

package/dist/main.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
+import { snapshotEnvironment } from "./process/snapshotEnvironment.js";
 import { pathToFileURL } from "node:url";
 import { realpathSync } from "node:fs";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
-import { parseConfig } from "./config.js";
+import { parseConfig } from "./config/parseConfig.js";
 import { createBinarySession } from "./composition/binary.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
-import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
 import { startMcpTransport } from "./main/transport.js";
-import { loadOptionalObservationProviders } from "./composition/optionalObservationProviders.js";
-import { registerConfigReload } from "./main/reload.js";
+import { createOptionalObservationFactories, loadOptionalObservationProviders, } from "./composition/optionalObservationProviders.js";
+import { createToolResultDelivery } from "./server/toolResult.js";
 import { createShutdown } from "./main/shutdown.js";
 const runtimeDependencies = () => ({
     env: process.env,
@@ -32,10 +32,6 @@ const runtimeDependencies = () => ({
             process.stdin.off("close", handler);
         };
     },
-    registerReload: (handler) => {
-        process.on("SIGHUP", handler);
-        return () => process.off("SIGHUP", handler);
-    },
 });
 /**
  * Start the long-lived MCP adapter and install idempotent shutdown handlers.
@@ -43,35 +39,32 @@ const runtimeDependencies = () => ({
  * signals close bridge resources without assuming ownership of the Hopper app.
  */
 export const run = async (dependencies = runtimeDependencies()) => {
-    const config = parseConfig(dependencies.env);
+    const environment = snapshotEnvironment(dependencies.env);
+    const config = parseConfig(environment);
     if (!config.ok) {
         dependencies.writeStderr(`${projectAnalysisError(config.error).message}\n`);
         return 1;
     }
     const logger = createLogger("mcp", config.value.logLevel);
     const serverLogger = logger.child({ layer: "server" });
-    const session = createBinarySession(config.value, logger);
+    const session = createBinarySession(config.value, logger, environment);
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
         return opened.exitCode;
-    const runtimeState = createRuntimeState(config.value);
     const transport = await startMcpTransport(dependencies, session, {
         logger,
         serverLogger,
-        loadOptionalProviders: dependencies.loadOptionalProviders ?? loadOptionalObservationProviders,
+        environment,
+        delivery: createToolResultDelivery(config.value.mcpMaxResponseBytes),
+        loadOptionalProviders: dependencies.loadOptionalProviders ??
+            (() => loadOptionalObservationProviders(createOptionalObservationFactories(environment))),
     });
     if (!transport.ok)
         return 1;
-    const unregisterReload = registerConfigReload({
-        dependencies,
-        runtimeState,
-        serverLogger,
-    });
     createShutdown({
         handle: transport.handle,
         closeAndroid: transport.closeAndroid,
         session,
-        unregisterReload,
         dependencies,
         serverLogger,
     });

package/dist/native/AppleMachoSelection.js

@@ -182,9 +182,14 @@ const collectFixupCommand = (bytes, { cursor, kind, size }, state) => {
             throw new RangeError("Fixup data exceeds the Mach-O slice");
         return { offset, size: length };
     };
-    if (kind === LC_DYLD_CHAINED_FIXUPS && size >= 16)
+    if (kind === LC_DYLD_CHAINED_FIXUPS) {
+        if (size < 16)
+            throw new RangeError("Truncated chained-fixups command");
         state.chained = range(cursor + 8);
-    else if ((kind === LC_DYLD_INFO || kind === LC_DYLD_INFO_ONLY) && size >= 48)
+    }
+    else if (kind === LC_DYLD_INFO || kind === LC_DYLD_INFO_ONLY) {
+        if (size < 48)
+            throw new RangeError("Truncated dyld-info command");
         for (const [at, stream] of [
             [cursor + 16, "bind"],
             [cursor + 24, "weak"],
@@ -194,11 +199,16 @@ const collectFixupCommand = (bytes, { cursor, kind, size }, state) => {
             if (bound.size > 0)
                 state.binds.push({ ...bound, stream });
         }
-    else if (DYLIB_COMMANDS.includes(kind) && size >= 24) {
+    }
+    else if (DYLIB_COMMANDS.includes(kind)) {
+        if (size < 24)
+            throw new RangeError("Truncated dylib command");
         const nameOffset = bytes.readUInt32LE(cursor + 8);
+        if (nameOffset < 24 || nameOffset >= size)
+            throw new RangeError("Dylib install name is outside its load command");
         const end = bytes.indexOf(0, cursor + nameOffset);
-        state.dylibs.push(nameOffset >= size || end < 0 || end > cursor + size
-            ? ""
-            : bytes.toString("utf8", cursor + nameOffset, end));
+        if (end < 0 || end >= cursor + size)
+            throw new RangeError("Unterminated dylib install name");
+        state.dylibs.push(bytes.toString("utf8", cursor + nameOffset, end));
     }
 };

package/dist/native/AppleObjcDispatchFacets.js

@@ -146,7 +146,7 @@ export const decodeObjcDispatchFacets = (input) => {
         if (superclass.name === null && superclass.address === null && !root)
             failures.push(`Superclass of ${name} requires external binding resolution`);
         const ivarList = read.pointer(ro + 48n);
-        let ivarCount = 0;
+        let ivarCount = meta ? null : 0;
         if (ivarList !== 0n && !meta) {
             const stride = read.u32(ivarList), count = read.u32(ivarList + 4n);
             if (stride !== 32)
@@ -198,8 +198,8 @@ export const decodeObjcDispatchFacets = (input) => {
                         BigInt(Number.MAX_SAFE_INTEGER)
                     ? Number(BigInt(item.implementation_address))
                     : null,
-                is_required: false,
-                is_optional: false,
+                is_required: null,
+                is_optional: null,
             })),
             properties: readObjcPropertiesOf(read, read.pointer(ro + 64n), {
                 owner: name,

package/dist/native/AppleObjcProperties.js

@@ -5,19 +5,29 @@ import { issue } from "./AppleDispatchDecodeFacts.js";
  */
 export const parsePropertyAttributes = (name, attributes) => {
     const tokens = attributes.length === 0 ? [] : splitAttributes(attributes);
-    const value = (code) => tokens.find((token) => token.startsWith(code))?.slice(1) ?? null;
+    const typeAttributes = tokens.filter((token) => token[0] === "T");
+    const typeAttribute = typeAttributes.length === 1 ? typeAttributes[0] : undefined;
+    const typeEncoding = typeAttribute !== undefined && typeAttribute.length > 1
+        ? typeAttribute.slice(1)
+        : null;
+    const value = (code) => tokens.find((token) => token[0] === code)?.slice(1) ?? null;
     return {
         name,
-        type_encoding: value("T"),
+        type_encoding: typeEncoding,
         attributes: tokens.map((token) => ({
             name: token.slice(0, 1),
             value: token.slice(1),
-            is_weak: token === "W",
-            is_atomic: false,
-            is_copy: token === "C",
-            is_strong: token === "&",
         })),
-        is_readonly: tokens.includes("R"),
+        atomicity: tokens.includes("N")
+            ? "nonatomic"
+            : typeEncoding === null
+                ? null
+                : "atomic",
+        is_readonly: tokens.includes("R")
+            ? true
+            : typeEncoding === null
+                ? null
+                : false,
         getter: value("G"),
         setter: value("S"),
     };

package/dist/native/CommandRunner.js

@@ -1,3 +1,4 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { realpath } from "node:fs/promises";
@@ -28,8 +29,10 @@ export class NativeCommandFailure extends Error {
 /** Run allowlisted Xcode tools directly without a shell. */
 export class XcrunCommandRunner {
     resolveTool;
-    constructor(resolveTool = (tool, signal) => resolveXcrunTool(tool, signal)) {
+    environment;
+    constructor(environment, resolveTool = (tool, signal) => resolveXcrunTool(tool, this.environment, signal)) {
         this.resolveTool = resolveTool;
+        this.environment = snapshotEnvironment(environment);
     }
     run(tool, arguments_, options) {
         if (!ALLOWED_TOOLS.has(tool))
@@ -37,7 +40,7 @@ export class XcrunCommandRunner {
         return this.resolveTool(tool, options.signal).then(async (resolved) => {
             if (!resolved.ok)
                 return resolved;
-            const captured = await captureProcess(resolved.value.path, arguments_, tool, options);
+            const captured = await captureProcess(resolved.value.path, arguments_, tool, options, this.environment);
             return captured.ok
                 ? ok({
                     ...captured.value,
@@ -66,8 +69,8 @@ const ALLOWED_TOOLS = new Set([
     "vtool",
 ]);
 /** Locate an Xcode tool through `xcrun --find` and sample its executable digest. */
-export const resolveXcrunTool = async (tool, signal) => {
-    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", signal === undefined ? {} : { signal });
+export const resolveXcrunTool = async (tool, environment, signal) => {
+    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", signal === undefined ? {} : { signal }, environment);
     if (!found.ok) {
         return err(new NativeCommandFailure(tool, found.error.reason === "nonzero-exit" ||
             found.error.reason === "unavailable"
@@ -99,7 +102,7 @@ const failureCapture = (capture, truncated) => ({
     signal: capture.signal,
     truncated,
 });
-const captureProcess = async (executable, arguments_, tool, options) => {
+const captureProcess = async (executable, arguments_, tool, options, environment) => {
     const runId = `rea-native-command-${randomUUID()}`;
     try {
         const snapshot = await runOwnedCommand({
@@ -107,11 +110,10 @@ const captureProcess = async (executable, arguments_, tool, options) => {
             arguments: [...arguments_],
             runId,
             env: {
-                PATH: "/usr/bin:/bin:/usr/sbin:/sbin",
                 LC_ALL: "C",
                 LANG: "C",
             },
-            hostEnvironment: {},
+            hostEnvironment: environment,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         }, {
             timeoutMs: NATIVE_COMMAND_TIMEOUT_MS,