rea-agents 3.0.0 → 3.2.0

package/dist/hopper/LinuxPrivateDisplayProbe.js

@@ -6,7 +6,6 @@ import { parseLinuxPrivateDisplayDiagnostic } from "./LinuxPrivateDisplayDiagnos
 const PYTHON_PATH = "/usr/bin/python3";
 const UNSHARE_PATH = "/usr/bin/unshare";
 const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
-const PROBE_OUTPUT_LIMIT_BYTES = 64 * 1024;
 /** Probe the exact Xvfb boundary and select the least-privileged viable strategy. */
 export const selectLinuxPrivateDisplayStrategy = async (options) => {
     const timeoutMs = options.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
@@ -26,7 +25,6 @@ export const selectLinuxPrivateDisplayStrategy = async (options) => {
             effective_socket_directory_mode: isolated.diagnostic.effective_socket_directory_mode,
             effective_mount_read_only: isolated.diagnostic.effective_mount_read_only,
             xvfb_stderr_bytes: isolated.diagnostic.xvfb_stderr_bytes,
-            xvfb_stderr_truncated: isolated.diagnostic.xvfb_stderr_truncated,
         });
     return {
         ok: true,
@@ -39,10 +37,10 @@ export const selectLinuxPrivateDisplayStrategy = async (options) => {
         },
     };
 };
-/** Run one helper probe in an owned process group with a hard output bound. */
+/** Run one helper probe in an owned process group and retain its full diagnostics. */
 export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
     if (options.signal?.aborted === true)
-        return emptyProcessResult({ cancelled: true });
+        return emptyProcessResult("cancelled");
     const command = privateDisplayProbeCommand(options.helperPath, strategy);
     let started;
     try {
@@ -54,16 +52,14 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         });
     }
     catch {
-        return emptyProcessResult();
+        return emptyProcessResult("launch-failed");
     }
     const launch = {
         process: started.process,
         ownsProcessLifetime: true,
         cleanup: () => cleanupOwnedProcessGroup(started.ownership),
     };
-    const supervisor = new ProviderProcessSupervisor(launch, {
-        maxOutputBytesPerStream: PROBE_OUTPUT_LIMIT_BYTES,
-    });
+    const supervisor = new ProviderProcessSupervisor(launch);
     const outcome = await waitForProbeExit(supervisor, options.timeoutMs, options.signal);
     let cleanupIncomplete = false;
     if (outcome !== "exit") {
@@ -74,12 +70,14 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         supervisor.dispose();
     const snapshot = supervisor.snapshot();
     return {
+        outcome: outcome === "exit"
+            ? "exited"
+            : outcome === "timeout"
+                ? "timed-out"
+                : "cancelled",
         exitCode: snapshot.exitCode,
         stderr: snapshot.stderr.text,
         stderrBytes: snapshot.stderr.bytes,
-        stderrTruncated: snapshot.stderr.truncated,
-        timedOut: outcome === "timeout",
-        cancelled: outcome === "cancelled",
         cleanupIncomplete,
     };
 };
@@ -119,22 +117,27 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
             diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
         };
     }
-    if (processResult.cancelled)
+    if (processResult.outcome === "cancelled")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "cancelled"),
         };
-    if (processResult.timedOut)
+    if (processResult.outcome === "timed-out")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "probe_timeout"),
         };
+    if (processResult.outcome === "launch-failed")
+        return {
+            ok: false,
+            diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
+        };
     if (processResult.cleanupIncomplete)
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "cleanup_incomplete"),
         };
-    const parsed = parseLinuxPrivateDisplayDiagnostic(processResult.stderr, processResult.stderrTruncated);
+    const parsed = parseLinuxPrivateDisplayDiagnostic(processResult.stderr);
     if (!parsed.ok)
         return {
             ok: false,
@@ -154,10 +157,8 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
 };
 const exitMatchesDiagnostic = (exitCode, diagnostic) => diagnostic.status === "ready"
     ? exitCode === 0
-    : diagnostic.failure_code !== null &&
-        hopperStartupExitCode(diagnostic.failure_code) === exitCode;
+    : hopperStartupExitCode(diagnostic.failure_code) === exitCode;
 const syntheticDiagnostic = (strategy, reason, failureCode = "private_display_unavailable") => ({
-    schema_version: 1,
     component: "hopper_private_display",
     operation: "probe",
     status: "error",
@@ -172,25 +173,19 @@ const syntheticDiagnostic = (strategy, reason, failureCode = "private_display_un
     strategy,
     fallback_reason: null,
     xvfb_stderr_bytes: 0,
-    xvfb_stderr_truncated: false,
 });
 const unavailable = (diagnostic) => ({
     ok: false,
     strategy: "unavailable",
-    exitCode: diagnostic.failure_code === null
-        ? 70
-        : (hopperStartupExitCode(diagnostic.failure_code) ?? 70),
+    exitCode: hopperStartupExitCode(diagnostic.failure_code) ?? 70,
     diagnostic: { ...diagnostic, strategy: "unavailable" },
 });
-const emptyProcessResult = (overrides = {}) => ({
+const emptyProcessResult = (outcome) => ({
+    outcome,
     exitCode: undefined,
     stderr: "",
     stderrBytes: 0,
-    stderrTruncated: false,
-    timedOut: false,
-    cancelled: false,
     cleanupIncomplete: false,
-    ...overrides,
 });
 const waitForProbeExit = async (supervisor, timeoutMs, signal) => {
     if (signal?.aborted === true)

package/dist/hopper/protocol.js

@@ -5,7 +5,7 @@ import { err, ok } from "../domain/result.js";
 const remoteErrorSchema = z
     .object({
     code: z.number().int(),
-    message: z.string().max(512),
+    message: z.string(),
     type: z
         .enum([
         "remote",
@@ -38,10 +38,10 @@ const eventSchema = z
         z
             .object({
             type: z.literal("progress"),
-            phase: z.string().min(1).max(64),
+            phase: z.string().min(1),
             completed: z.number().nonnegative().finite(),
             total: z.number().nonnegative().finite().nullable(),
-            message: z.string().min(1).max(512),
+            message: z.string().min(1),
             terminal: z.boolean().optional(),
         })
             .strict(),
@@ -82,5 +82,7 @@ export const parseBridgeMessageLine = (line) => {
 };
 /** Project a parsed response into its result or expected remote failure. */
 export const responseResult = (response) => "error" in response
-    ? err(new HopperRemoteError(response.error.code, response.error.message, response.error.type))
+    ? err(new HopperRemoteError(response.error.code, response.error.message, {
+        diagnosticType: response.error.type,
+    }))
     : ok(response.result);

package/dist/main/reload.js

@@ -2,7 +2,7 @@ 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, liveServers, serverLogger, } = input;
+    const { dependencies, permissionAuthority, runtimeState, serverLogger } = input;
     let reloadQueue = Promise.resolve();
     return (dependencies.registerReload?.(() => {
         const refreshed = parseConfig(dependencies.env);
@@ -33,14 +33,6 @@ export const registerConfigReload = (input) => {
                 return;
             }
             runtimeState.currentConfig = refreshed.value;
-            Object.assign(runtimeState.processPolicy, refreshed.value.processExecutionPolicy);
-            Object.assign(runtimeState.evidencePolicy, refreshed.value.evidenceFilePolicy);
-            Object.assign(runtimeState.snapshotPolicy, refreshed.value.analysisSnapshotFilePolicy);
-            runtimeState.investigationRoots.splice(0, runtimeState.investigationRoots.length, ...refreshed.value.investigationInputRoots);
-            Object.assign(runtimeState.javascriptReplayPolicy, refreshed.value.javascriptReplayPolicy);
-            Object.assign(runtimeState.managedRuntimePolicy, refreshed.value.managedRuntimePolicy);
-            for (const server of liveServers)
-                server.sendToolListChanged();
         })
             .catch(() => {
             serverLogger.error(MCP_PERMISSION_RELOAD_FAILED);

package/dist/main/shutdown.js

@@ -8,7 +8,7 @@ export const createShutdown = (input) => {
             unregisterReload();
             unregisterShutdown();
             await handle.close();
-            await session.close();
+            await session.close({ retainProviderDocuments: true });
             permissionAuthority.clearSessionGrants();
         })();
         return shutdownPromise;

package/dist/main/state.js

@@ -1,26 +1,3 @@
 export const createRuntimeState = (config) => ({
     currentConfig: config,
-    processPolicy: {
-        ...config.processExecutionPolicy,
-        executableRoots: [...config.processExecutionPolicy.executableRoots],
-        workingRoots: [...config.processExecutionPolicy.workingRoots],
-        allowedEnvironment: [...config.processExecutionPolicy.allowedEnvironment],
-    },
-    evidencePolicy: {
-        ...config.evidenceFilePolicy,
-        roots: [...config.evidenceFilePolicy.roots],
-    },
-    snapshotPolicy: {
-        ...config.analysisSnapshotFilePolicy,
-        roots: [...config.analysisSnapshotFilePolicy.roots],
-    },
-    investigationRoots: [...config.investigationInputRoots],
-    javascriptReplayPolicy: {
-        ...config.javascriptReplayPolicy,
-        roots: [...config.javascriptReplayPolicy.roots],
-    },
-    managedRuntimePolicy: {
-        ...config.managedRuntimePolicy,
-        roots: [...config.managedRuntimePolicy.roots],
-    },
 });

package/dist/main/transport.js

@@ -1,28 +1,27 @@
 import { createServer, } from "../server/createServer.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
-    const liveServers = new Set();
     const { serverLogger } = serverContext;
+    let optionalProviders = {};
+    try {
+        optionalProviders = await serverContext.loadOptionalProviders();
+    }
+    catch {
+        serverLogger.warn("Optional MCP providers could not load; affected tools remain unavailable");
+    }
     let handle;
     try {
-        handle = dependencies.serve(() => {
-            const server = (dependencies.createServer ?? createServer)(session, session, {
-                logger: serverContext.logger,
-                processPolicy: serverContext.runtimeState.processPolicy,
-                evidenceFilePolicy: serverContext.runtimeState.evidencePolicy,
-                investigationInputRoots: serverContext.runtimeState.investigationRoots,
-                analysisSnapshotFilePolicy: serverContext.runtimeState.snapshotPolicy,
-                permissionAuthority: serverContext.permissionAuthority,
-                loadOptionalProviders: serverContext.loadOptionalProviders,
-                artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
-                    .artifactIntegrityContinueEnabled,
-                javascriptReplayPolicy: serverContext.runtimeState.javascriptReplayPolicy,
-                managedRuntimePolicy: serverContext.runtimeState.managedRuntimePolicy,
-                availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
-            });
-            liveServers.add(server);
-            return server;
-        }, {
+        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);
                 dependencies.writeStderr(`${MCP_CONNECTION_LOST}\n`);
@@ -35,26 +34,15 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
         return { ok: false };
     }
-    return { ok: true, handle, liveServers };
+    return { ok: true, handle };
 };
 const runtimeAvailability = (state) => ({
-    processCaptureEnabled: state.currentConfig.processExecutionPolicy.enabled,
-    evidenceFileRoots: state.currentConfig.evidenceFilePolicy.roots.length,
-    investigationInputRoots: state.currentConfig.investigationInputRoots.length,
-    browserObservationEnabled: state.currentConfig.browserObservationEnabled &&
-        state.currentConfig.browserCdpEndpoints.length > 0 &&
-        state.currentConfig.browserAllowedOrigins.length > 0,
-    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.enabled &&
-        state.currentConfig.browserScenarioPolicy.allowedOrigins.length > 0 &&
-        (state.currentConfig.browserScenarioPolicy.executableRoots.length > 0 ||
-            state.currentConfig.browserScenarioPolicy.cdpEndpoints.length > 0),
-    electronObservationEnabled: state.currentConfig.electronObservationEnabled &&
-        state.currentConfig.electronCdpEndpoints.length > 0 &&
-        state.currentConfig.electronFileRoots.length > 0,
-    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationEnabled &&
-        state.currentConfig.v8InspectorEndpoints.length > 0 &&
-        (state.currentConfig.v8InspectorFileRoots.length > 0 ||
-            state.currentConfig.v8InspectorAllowedOrigins.length > 0),
-    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.enabled,
-    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.enabled,
+    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

@@ -63,20 +63,23 @@ export const run = async (dependencies = runtimeDependencies()) => {
     const transport = await startMcpTransport(dependencies, session, {
         logger,
         serverLogger,
-        loadOptionalProviders: async () => {
-            const [{ CdpBrowserProvider }, { PlaywrightBrowserScenarioProvider }, { CdpElectronProvider }, { V8InspectorProvider },] = await Promise.all([
-                import("./browser/CdpBrowserProvider.js"),
-                import("./browser/PlaywrightBrowserScenarioProvider.js"),
-                import("./browser/CdpElectronProvider.js"),
-                import("./browser/V8InspectorProvider.js"),
-            ]);
-            return {
-                browserObservation: new CdpBrowserProvider(),
-                browserScenarioCapture: new PlaywrightBrowserScenarioProvider(),
-                electronObservation: new CdpElectronProvider(),
-                javascriptRuntimeObservation: new V8InspectorProvider(),
-            };
-        },
+        loadOptionalProviders: dependencies.loadOptionalProviders ??
+            (async () => {
+                const [{ CdpBrowserProvider }, { PlaywrightBrowserScenarioProvider }, { CdpElectronProvider }, { PlaywrightElectronActiveProvider }, { V8InspectorProvider },] = await Promise.all([
+                    import("./browser/CdpBrowserProvider.js"),
+                    import("./browser/PlaywrightBrowserScenarioProvider.js"),
+                    import("./browser/CdpElectronProvider.js"),
+                    import("./browser/PlaywrightElectronActiveProvider.js"),
+                    import("./browser/V8InspectorProvider.js"),
+                ]);
+                return {
+                    browserObservation: new CdpBrowserProvider(),
+                    browserScenarioCapture: new PlaywrightBrowserScenarioProvider(),
+                    electronObservation: new CdpElectronProvider(),
+                    electronActiveObservation: new PlaywrightElectronActiveProvider(),
+                    javascriptRuntimeObservation: new V8InspectorProvider(),
+                };
+            }),
         permissionAuthority: permissionAuthority.value,
         runtimeState,
     });
@@ -86,7 +89,6 @@ export const run = async (dependencies = runtimeDependencies()) => {
         dependencies,
         permissionAuthority: permissionAuthority.value,
         runtimeState,
-        liveServers: transport.liveServers,
         serverLogger,
     });
     createShutdown({

package/dist/mcpDoctor.js

@@ -2,18 +2,18 @@ import { Client } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { Formatter } from "incur";
 import { resolve } from "node:path";
-import { CATALOG_IDENTITY, MCP_RESOURCE_CATALOG, MCP_RESOURCE_TEMPLATE_CATALOG, } from "./catalogIdentity.js";
+import { CATALOG_IDENTITY } from "./catalogIdentity.js";
 import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
+import { TOOL_CONTRACTS } from "./contracts/toolContracts.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { MCP_STARTUP_POLICY } from "./mcpStartupPolicy.js";
-const STDERR_LIMIT_BYTES = 64 * 1_024;
 const OUTPUT_FORMATS = ["toon", "json", "yaml", "md", "jsonl"];
-/** Diagnose the actual production stdio adapter with one bounded SDK session. */
+/** Diagnose the actual production stdio adapter with one startup-bounded SDK session. */
 export const runProductionMcpDoctor = async (options) => {
     const deadline = Date.now() + (options.deadlineMs ?? MCP_STARTUP_POLICY.doctorDeadlineMs);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error("Production MCP doctor deadline expired")), Math.max(1, deadline - Date.now()));
-    const stderr = boundedStderr();
+    const stderr = captureStderr();
     const transport = new TrackedStdioClientTransport({
         command: options.command,
         args: [...options.args],
@@ -55,22 +55,16 @@ export const runProductionMcpDoctor = async (options) => {
 };
 const inspectProductionMcpSession = async (client, deadline, signal) => {
     const request = requestOptions(deadline, signal);
-    const [tools, prompts, resources, templates, identity, requestFlow] = await Promise.all([
+    const [tools, prompts, requestFlow] = await Promise.all([
         client.listTools(undefined, request),
         client.listPrompts(undefined, request),
-        client.listResources(undefined, request),
-        client.listResourceTemplates(undefined, request),
-        client.readResource({ uri: "rea://server/identity" }, request),
-        client.callTool({ name: "binary_session", arguments: { detail: "full" } }, request),
+        client.callTool({ name: "binary_session", arguments: {} }, request),
     ]);
-    const expectedToolNames = availableToolNames(requestFlow.structuredContent) ?? [];
     const inventory = {
-        tools: compareInventory(expectedToolNames, tools.tools.map(({ name }) => name)),
+        tools: compareInventory(TOOL_CONTRACTS.map(({ name }) => name), tools.tools.map(({ name }) => name)),
         prompts: compareInventory(PROMPT_CONTRACTS.map(({ name }) => name), prompts.prompts.map(({ name }) => name)),
-        resources: compareInventory(MCP_RESOURCE_CATALOG.map(({ name }) => name), resources.resources.map(({ name }) => name)),
-        resource_templates: compareInventory(MCP_RESOURCE_TEMPLATE_CATALOG.map(({ name }) => name), templates.resourceTemplates.map(({ name }) => name)),
     };
-    const observedIdentity = parseIdentityResource(identity.contents);
+    const observedIdentity = parseIdentityToolResult(requestFlow.structuredContent);
     const serverVersion = client.getServerVersion();
     const protocolVersion = client.getNegotiatedProtocolVersion();
     const checks = [
@@ -117,28 +111,6 @@ const inspectProductionMcpSession = async (client, deadline, signal) => {
         checks,
     };
 };
-const availableToolNames = (structuredContent) => {
-    if (typeof structuredContent !== "object" || structuredContent === null)
-        return undefined;
-    const result = Reflect.get(structuredContent, "result");
-    if (typeof result !== "object" || result === null)
-        return undefined;
-    const availability = Reflect.get(result, "tool_availability");
-    if (!Array.isArray(availability))
-        return undefined;
-    const names = [];
-    for (const item of availability) {
-        if (typeof item !== "object" || item === null)
-            return undefined;
-        const name = Reflect.get(item, "name");
-        const available = Reflect.get(item, "available");
-        if (typeof name !== "string" || typeof available !== "boolean")
-            return undefined;
-        if (available)
-            names.push(name);
-    }
-    return names;
-};
 /**
  * Dispatcher entry for `rea mcp doctor`, kept separate from Incur MCP setup.
  * @public
@@ -183,29 +155,23 @@ const inventoryCheck = (name, comparison) => ({
         comparison.duplicates.length === 0,
     detail: `expected=${String(comparison.expected)} observed=${String(comparison.observed)} missing=${comparison.missing.join(",") || "none"} unexpected=${comparison.unexpected.join(",") || "none"} duplicates=${comparison.duplicates.join(",") || "none"}`,
 });
-const parseIdentityResource = (contents) => {
-    const first = contents.find((candidate) => isRecord(candidate) && typeof candidate.text === "string");
-    if (!isRecord(first) || typeof first.text !== "string")
+const parseIdentityToolResult = (input) => {
+    if (!isRecord(input) || !isRecord(input.result))
         return { packageVersion: null, catalogDigest: null };
-    try {
-        const identity = JSON.parse(first.text);
-        if (!isRecord(identity))
-            return { packageVersion: null, catalogDigest: null };
-        const packageIdentity = identity.package;
-        const catalog = identity.catalog;
-        const digests = isRecord(catalog) ? catalog.digests : undefined;
-        return {
-            packageVersion: isRecord(packageIdentity) && typeof packageIdentity.version === "string"
-                ? packageIdentity.version
-                : null,
-            catalogDigest: isRecord(digests) && typeof digests.combined_sha256 === "string"
-                ? digests.combined_sha256
-                : null,
-        };
-    }
-    catch {
+    const identity = input.result.server_identity;
+    if (!isRecord(identity))
         return { packageVersion: null, catalogDigest: null };
-    }
+    const packageIdentity = identity.package;
+    const catalog = identity.catalog;
+    const digests = isRecord(catalog) ? catalog.digests : undefined;
+    return {
+        packageVersion: isRecord(packageIdentity) && typeof packageIdentity.version === "string"
+            ? packageIdentity.version
+            : null,
+        catalogDigest: isRecord(digests) && typeof digests.combined_sha256 === "string"
+            ? digests.combined_sha256
+            : null,
+    };
 };
 const parseOutputArguments = (arguments_) => {
     let format = "toon";
@@ -256,28 +222,20 @@ const targetFreeEnvironment = (environment) => {
         delete result[name];
     return result;
 };
-const boundedStderr = () => {
-    let text = "";
+const captureStderr = () => {
+    const chunks = [];
     let bytes = 0;
-    let truncated = false;
     return {
         append(chunk) {
             const buffer = Buffer.isBuffer(chunk)
                 ? chunk
                 : Buffer.from(String(chunk), "utf8");
             bytes += buffer.byteLength;
-            const retained = Buffer.byteLength(text, "utf8");
-            if (retained < STDERR_LIMIT_BYTES)
-                text += buffer
-                    .subarray(0, STDERR_LIMIT_BYTES - retained)
-                    .toString("utf8");
-            if (bytes > STDERR_LIMIT_BYTES)
-                truncated = true;
+            chunks.push(Buffer.from(buffer));
         },
         value: () => ({
-            stderr: text,
+            stderr: Buffer.concat(chunks, bytes).toString("utf8"),
             stderr_bytes: bytes,
-            stderr_truncated: truncated,
         }),
     };
 };

package/dist/native/CommandRunner.js

@@ -14,17 +14,17 @@ export class NativeCommandFailure extends Error {
         this.exitCode = exitCode;
     }
 }
-/** Run allowlisted Xcode tools directly with bounded output and no shell. */
+/** Run allowlisted Xcode tools directly without a shell. */
 export class XcrunCommandRunner {
     resolveTool;
     #resolved = new Map();
-    constructor(resolveTool = (tool) => resolveXcrunTool(tool)) {
+    constructor(resolveTool = (tool, signal) => resolveXcrunTool(tool, signal)) {
         this.resolveTool = resolveTool;
     }
     run(tool, arguments_, options) {
         if (!ALLOWED_TOOLS.has(tool))
             return Promise.resolve(err(new NativeCommandFailure(tool, "unavailable")));
-        return this.#resolve(tool).then(async (resolved) => {
+        return this.#resolve(tool, options.signal).then(async (resolved) => {
             if (!resolved.ok)
                 return resolved;
             const captured = await captureProcess(resolved.value.path, arguments_, tool, options);
@@ -41,15 +41,13 @@ export class XcrunCommandRunner {
                 : captured;
         });
     }
-    async #resolve(tool) {
+    async #resolve(tool, signal) {
         const existing = this.#resolved.get(tool);
         if (existing !== undefined)
-            return existing;
-        const pending = this.resolveTool(tool);
-        this.#resolved.set(tool, pending);
-        const resolved = await pending;
-        if (!resolved.ok && this.#resolved.get(tool) === pending)
-            this.#resolved.delete(tool);
+            return ok(existing);
+        const resolved = await this.resolveTool(tool, signal);
+        if (resolved.ok)
+            this.#resolved.set(tool, resolved.value);
         return resolved;
     }
 }
@@ -66,9 +64,14 @@ const ALLOWED_TOOLS = new Set([
     "swift-demangle",
     "vtool",
 ]);
-const resolveXcrunTool = async (tool) => {
-    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", { timeoutMs: 5_000, maxOutputBytes: 64 * 1024 });
-    if (!found.ok || found.value.exitCode !== 0)
+const resolveXcrunTool = async (tool, signal) => {
+    const found = await captureProcess("/usr/bin/xcrun", ["--find", tool], "xcrun", signal === undefined ? {} : { signal });
+    if (!found.ok) {
+        if (found.error.reason === "cancelled")
+            return err(new NativeCommandFailure(tool, "cancelled"));
+        return err(new NativeCommandFailure(tool, "unavailable"));
+    }
+    if (found.value.exitCode !== 0)
         return err(new NativeCommandFailure(tool, "unavailable"));
     const candidate = found.value.stdout.trim();
     if (!candidate.startsWith("/"))
@@ -107,7 +110,6 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
         if (settled)
             return;
         settled = true;
-        clearTimeout(timeout);
         options.signal?.removeEventListener("abort", onAbort);
         resolve(result);
     };
@@ -117,20 +119,13 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
     };
     const onAbort = () => stop("cancelled");
     options.signal?.addEventListener("abort", onAbort, { once: true });
-    const timeout = setTimeout(() => stop("timeout"), options.timeoutMs);
     child.stdout.on("data", (chunk) => {
         stdoutBytes += chunk.length;
-        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
-            stop("output-limit");
-        else
-            stdout.push(chunk);
+        stdout.push(chunk);
     });
     child.stderr.on("data", (chunk) => {
         stderrBytes += chunk.length;
-        if (stdoutBytes + stderrBytes > options.maxOutputBytes)
-            stop("output-limit");
-        else
-            stderr.push(chunk);
+        stderr.push(chunk);
     });
     child.once("error", (cause) => finish(err(new NativeCommandFailure(tool, "io", null, { cause }))));
     child.once("close", (code, signal) => {
@@ -147,8 +142,6 @@ const captureProcess = (executable, arguments_, tool, options) => new Promise((r
             stderr: Buffer.concat(stderr).toString("utf8"),
             stdoutBytes,
             stderrBytes,
-            stdoutTruncated: false,
-            stderrTruncated: false,
             exitCode: code,
             signal,
         }));