rea-agents 1.7.0 → 2.1.0

package/dist/main.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import { pathToFileURL } from "node:url";
 import { realpathSync } from "node:fs";
-import { serveStdio, } from "@modelcontextprotocol/server/stdio";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { parseConfig } from "./config.js";
 import { createBinarySession } from "./application/runtime.js";
-import { createServer } from "./server/createServer.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/errors.js";
-import { readProjectPermissionStore } from "./application/ProjectPermissionStore.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
 import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
-const MCP_CONNECTION_LOST = "REA lost its MCP client connection. Restart REA from your MCP client.";
-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.";
-const MCP_SHUTDOWN_FAILED = "REA could not close cleanly. End the REA process before starting it again.";
-const SERVER_START_FAILED = "REA could not start. Run `rea doctor`, then restart REA from your MCP client.";
+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 { registerConfigReload } from "./main/reload.js";
+import { createShutdown } from "./main/shutdown.js";
 const runtimeDependencies = () => ({
     env: process.env,
     serve: serveStdio,
@@ -60,132 +60,35 @@ export const run = async (dependencies = runtimeDependencies()) => {
     const session = createBinarySession(config.value, logger);
     const browserObservation = new CdpBrowserProvider();
     const electronObservation = new CdpElectronProvider();
-    if (config.value.hopperTargetPath !== undefined) {
-        const opened = await session.open(config.value.hopperTargetPath, {
-            targetKind: config.value.hopperTargetKind,
-        });
-        if (!opened.ok) {
-            await session.close();
-            serverLogger.error({ errorTag: opened.error._tag }, "Initial target failed to open");
-            dependencies.writeStderr(`${projectAnalysisError(opened.error).message}\n`);
-            return 1;
-        }
-    }
-    let currentConfig = config.value;
-    const runtimeProcessPolicy = {
-        ...config.value.processExecutionPolicy,
-        executableRoots: [...config.value.processExecutionPolicy.executableRoots],
-        workingRoots: [...config.value.processExecutionPolicy.workingRoots],
-        allowedEnvironment: [
-            ...config.value.processExecutionPolicy.allowedEnvironment,
-        ],
-    };
-    const runtimeEvidencePolicy = {
-        ...config.value.evidenceFilePolicy,
-        roots: [...config.value.evidenceFilePolicy.roots],
-    };
-    const runtimeSnapshotPolicy = {
-        ...config.value.analysisSnapshotFilePolicy,
-        roots: [...config.value.analysisSnapshotFilePolicy.roots],
-    };
-    const runtimeInvestigationRoots = [...config.value.investigationInputRoots];
-    const liveServers = new Set();
-    let handle;
-    try {
-        handle = dependencies.serve(() => {
-            const server = (dependencies.createServer ?? createServer)(session, session, {
-                logger,
-                processPolicy: runtimeProcessPolicy,
-                evidenceFilePolicy: runtimeEvidencePolicy,
-                investigationInputRoots: runtimeInvestigationRoots,
-                analysisSnapshotFilePolicy: runtimeSnapshotPolicy,
-                permissionAuthority: permissionAuthority.value,
-                browserObservation,
-                electronObservation,
-                artifactIntegrityContinueEnabled: () => currentConfig.artifactIntegrityContinueEnabled,
-                availabilityPolicy: () => ({
-                    processCaptureEnabled: currentConfig.processExecutionPolicy.enabled,
-                    evidenceFileRoots: currentConfig.evidenceFilePolicy.roots.length,
-                    browserObservationEnabled: currentConfig.browserObservationEnabled &&
-                        currentConfig.browserCdpEndpoints.length > 0 &&
-                        currentConfig.browserAllowedOrigins.length > 0,
-                    electronObservationEnabled: currentConfig.electronObservationEnabled &&
-                        currentConfig.electronCdpEndpoints.length > 0 &&
-                        currentConfig.electronFileRoots.length > 0,
-                }),
-            });
-            liveServers.add(server);
-            return server;
-        }, {
-            onerror: () => {
-                serverLogger.error(MCP_CONNECTION_LOST);
-                dependencies.writeStderr(`${MCP_CONNECTION_LOST}\n`);
-            },
-        });
-    }
-    catch {
-        await session.close();
-        serverLogger.error(MCP_CONNECTION_START_FAILED);
-        dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
+    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,
+        browserObservation,
+        electronObservation,
+        permissionAuthority: permissionAuthority.value,
+        runtimeState,
+    });
+    if (!transport.ok)
         return 1;
-    }
-    let reloadQueue = Promise.resolve();
-    const unregisterReload = dependencies.registerReload?.(() => {
-        const refreshed = parseConfig(dependencies.env);
-        if (!refreshed.ok) {
-            serverLogger.error("Reloaded permission policy 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.value.replaceConfiguredPolicy({
-                ceilings: refreshed.value.permissionCeilings,
-                administratorGrants: refreshed.value.administratorPermissionGrants,
-                projectGrants,
-            });
-            if (!reloaded.ok) {
-                serverLogger.error("Reloaded permission policy could not be applied");
-                return;
-            }
-            currentConfig = refreshed.value;
-            Object.assign(runtimeProcessPolicy, refreshed.value.processExecutionPolicy);
-            Object.assign(runtimeEvidencePolicy, refreshed.value.evidenceFilePolicy);
-            Object.assign(runtimeSnapshotPolicy, refreshed.value.analysisSnapshotFilePolicy);
-            runtimeInvestigationRoots.splice(0, runtimeInvestigationRoots.length, ...refreshed.value.investigationInputRoots);
-            for (const server of liveServers)
-                server.sendToolListChanged();
-        });
-    }) ?? (() => undefined);
-    let shutdownPromise;
-    let unregisterShutdown = () => undefined;
-    const shutdown = () => {
-        shutdownPromise ??= (async () => {
-            unregisterReload();
-            unregisterShutdown();
-            await handle.close();
-            await session.close();
-            permissionAuthority.value.clearSessionGrants();
-        })();
-        return shutdownPromise;
-    };
-    const requestShutdown = () => {
-        shutdown().catch(() => {
-            dependencies.setExitCode(1);
-            serverLogger.error(MCP_SHUTDOWN_FAILED);
-            dependencies.writeStderr(`${MCP_SHUTDOWN_FAILED}\n`);
-        });
-    };
-    unregisterShutdown = dependencies.registerShutdown(requestShutdown);
+    const unregisterReload = registerConfigReload({
+        dependencies,
+        permissionAuthority: permissionAuthority.value,
+        runtimeState,
+        liveServers: transport.liveServers,
+        serverLogger,
+    });
+    createShutdown({
+        handle: transport.handle,
+        session,
+        permissionAuthority: permissionAuthority.value,
+        unregisterReload,
+        dependencies,
+        serverLogger,
+    });
     return 0;
 };
 /** Run the executable boundary without exposing an unexpected startup cause. */

package/dist/process/PrivateRuntimeRoot.js

@@ -2,10 +2,11 @@ import { chmod, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 /**
- * Owns one mode-0700 temporary runtime root and removes it idempotently.
+ * Owns one POSIX mode-0700 temporary runtime root and removes it idempotently.
  *
  * Protocol adapters decide what belongs inside the directory; this primitive
- * only establishes a private filesystem boundary and deterministic cleanup.
+ * establishes a private filesystem boundary on POSIX and deterministic cleanup.
+ * Windows privacy requires the separately verified native DACL boundary.
  */
 export class PrivateRuntimeRoot {
     path;

package/dist/process/ProcessOwnership.js

@@ -2,6 +2,26 @@ import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
+/**
+ * Terminate one Windows process tree through the platform utility.
+ *
+ * This is a bounded P0 cleanup mechanism, not Job Object ownership proof. The
+ * caller-visible Windows limitations must preserve that distinction.
+ */
+export const cleanupWindowsProcessTree = async (rootPid, host = systemWindowsProcessTreeHost) => {
+    if (!Number.isSafeInteger(rootPid) || rootPid <= 0)
+        return { cleaned: false, reason: "Windows process-tree PID is invalid" };
+    try {
+        const result = await host.terminateTree(rootPid);
+        return { cleaned: true, signaled: result === "terminated" };
+    }
+    catch {
+        return {
+            cleaned: false,
+            reason: "Windows P0 process-tree termination failed; Job Object ownership is unavailable",
+        };
+    }
+};
 /** Select the PTY root group and groups led by an observed captured process. */
 export const selectCapturedProcessGroupIds = (rootPid, samples) => {
     const processGroupIds = new Set([rootPid]);
@@ -58,6 +78,21 @@ const systemHost = {
         process.kill(-processGroupId, signal);
     },
 };
+const systemWindowsProcessTreeHost = {
+    async terminateTree(rootPid) {
+        try {
+            await execFileAsync("taskkill.exe", ["/pid", String(rootPid), "/t", "/f"], { windowsHide: true, timeout: 5_000 });
+            return "terminated";
+        }
+        catch (cause) {
+            if (cause instanceof Error &&
+                "code" in cause &&
+                (cause.code === 128 || cause.code === "ESRCH"))
+                return "missing";
+            throw cause;
+        }
+    },
+};
 /** Read the capture run token currently exposed by one live process. */
 export const readProcessRunId = async (pid, host = systemHost) => (await host.environment(pid)).REA_PROCESS_RUN_ID;
 /**

package/dist/process/ProviderProcess.js

@@ -11,8 +11,10 @@ const DEFAULT_KILL_GRACE_MS = 1_000;
 export const spawnOwnedProviderProcess = async (options) => {
     const child = spawn(options.command, [...options.arguments], {
         shell: false,
+        windowsHide: true,
         stdio: ["ignore", "pipe", "pipe"],
         detached: process.platform !== "win32",
+        windowsVerbatimArguments: options.windowsVerbatimArguments ?? false,
         env: {
             ...process.env,
             ...options.env,

package/dist/replay/JavaScriptReplayWorker.js

@@ -0,0 +1,300 @@
+import { Script, SourceTextModule, SyntheticModule, createContext, } from "node:vm";
+import { types } from "node:util";
+class ReplayDeniedError extends Error {
+    name = "ReplayDeniedError";
+}
+const main = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (request.schemaVersion !== 1)
+        throw new TypeError("Unsupported replay worker protocol");
+    const left = [];
+    const right = [];
+    for (let index = 0; index < request.cases.length; index += 1) {
+        const replayCase = request.cases[index];
+        if (replayCase === undefined)
+            continue;
+        left.push(await runCase(request.left, replayCase, request, index));
+        if (request.right !== undefined)
+            right.push(await runCase(request.right, replayCase, request, index));
+    }
+    process.stdout.write(JSON.stringify({
+        schema_version: 1,
+        left,
+        ...(request.right === undefined ? {} : { right }),
+    }));
+};
+const runCase = async (side, replayCase, request, index) => {
+    try {
+        const loaded = await loadEntry(side, request, index);
+        if (typeof loaded !== "function")
+            throw new TypeError(`Replay export is not callable: ${side.entryExport}`);
+        const returned = await Reflect.apply(loaded, undefined, [
+            ...replayCase.arguments,
+        ]);
+        try {
+            return {
+                case_id: replayCase.caseId,
+                outcome: "return",
+                value: projectValue(returned, request.limits.resultDepth, request.limits.resultNodes),
+                input_sha256: replayCase.inputSha256,
+                output_sha256: null,
+                truncated: false,
+            };
+        }
+        catch (error) {
+            return exceptionOutcome(replayCase, "serialization_error", error, request.limits.exceptionBytes);
+        }
+    }
+    catch (error) {
+        return exceptionOutcome(replayCase, error instanceof ReplayDeniedError ? "denied" : "exception", error, request.limits.exceptionBytes);
+    }
+};
+const loadEntry = async (side, request, caseIndex) => {
+    const modules = new Map(side.modules.map((module) => [module.alias, module]));
+    const context = deterministicContext(request, caseIndex);
+    const esmCache = new Map();
+    const commonJsCache = new Map();
+    const loadCommonJs = (alias) => {
+        const cached = commonJsCache.get(alias);
+        if (cached !== undefined)
+            return cached;
+        const descriptor = requiredModule(modules, alias);
+        if (descriptor.format !== "commonjs-factory")
+            throw new TypeError(`Synchronous require cannot load ESM module: ${alias}`);
+        const module = { exports: {} };
+        commonJsCache.set(alias, module.exports);
+        const requireModule = ((specifier) => {
+            const dependency = descriptor.dependencies[specifier];
+            if (dependency === undefined)
+                throw new ReplayDeniedError(`Undeclared require: ${specifier}`);
+            return loadCommonJs(dependency);
+        });
+        installRspackHelpers(requireModule);
+        const source = normalizeFactorySource(descriptor.source);
+        const factory = new Script(`(${source})`, {
+            filename: `/modules/${alias}.js`,
+        }).runInContext(context);
+        factory(module, module.exports, requireModule);
+        commonJsCache.set(alias, module.exports);
+        return module.exports;
+    };
+    const loadEsm = async (alias) => {
+        const cached = esmCache.get(alias);
+        if (cached !== undefined)
+            return cached;
+        const descriptor = requiredModule(modules, alias);
+        let module;
+        if (descriptor.format === "commonjs-factory") {
+            const exports = loadCommonJs(alias);
+            const names = [...new Set(["default", ...Object.keys(exports)])];
+            module = new SyntheticModule(names, function () {
+                this.setExport("default", exports);
+                for (const name of Object.keys(exports))
+                    this.setExport(name, exports[name]);
+            }, { context, identifier: `rea:${alias}` });
+        }
+        else {
+            module = new SourceTextModule(descriptor.source, {
+                context,
+                identifier: `rea:${alias}`,
+                initializeImportMeta: (meta) => {
+                    meta.url = `rea:${alias}`;
+                },
+                importModuleDynamically: () => {
+                    throw new ReplayDeniedError("Dynamic import is unavailable in controlled replay");
+                },
+            });
+        }
+        esmCache.set(alias, module);
+        await module.link(async (specifier) => {
+            const dependency = descriptor.dependencies[specifier];
+            if (dependency === undefined)
+                throw new ReplayDeniedError(`Undeclared import: ${specifier}`);
+            return loadEsm(dependency);
+        });
+        await module.evaluate();
+        return module;
+    };
+    const entry = requiredModule(modules, side.entryAlias);
+    if (entry.format === "commonjs-factory") {
+        const exported = loadCommonJs(side.entryAlias);
+        return side.entryExport === "default"
+            ? (exported.default ?? exported)
+            : exported[side.entryExport];
+    }
+    const namespace = (await loadEsm(side.entryAlias)).namespace;
+    return namespace[side.entryExport];
+};
+const deterministicContext = (request, caseIndex) => {
+    let state = (request.determinism.randomSeed + caseIndex) >>> 0;
+    const random = () => {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        return (state >>> 0) / 0x1_0000_0000;
+    };
+    const epoch = Date.parse(request.determinism.clockIso);
+    class ReplayDate extends Date {
+        constructor(...arguments_) {
+            super(arguments_.length === 0 ? epoch : arguments_[0]);
+        }
+        static now() {
+            return epoch;
+        }
+    }
+    const replayMath = Object.create(Math);
+    Object.defineProperty(replayMath, "random", { value: random });
+    return createContext({ Date: ReplayDate, Math: replayMath }, {
+        name: "rea-controlled-replay",
+        codeGeneration: { strings: false, wasm: false },
+    });
+};
+const installRspackHelpers = (require_) => {
+    require_.d = (exports, definitions) => {
+        for (const [name, getter] of Object.entries(definitions))
+            if (!Object.prototype.hasOwnProperty.call(exports, name))
+                Object.defineProperty(exports, name, { enumerable: true, get: getter });
+    };
+    require_.r = (exports) => {
+        Object.defineProperty(exports, "__esModule", { value: true });
+        Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+    };
+    require_.n = (module) => {
+        const getter = () => (module.__esModule === true ? module.default : module);
+        Object.defineProperty(getter, "a", { get: getter });
+        return getter;
+    };
+    require_.nmd = (module) => module;
+};
+const requiredModule = (modules, alias) => {
+    const module = modules.get(alias);
+    if (module === undefined)
+        throw new TypeError(`Undeclared module alias: ${alias}`);
+    return module;
+};
+const normalizeFactorySource = (source) => /^\s*\d+\s*\(/u.test(source)
+    ? source.replace(/^\s*\d+\s*\(/u, "function(")
+    : source;
+const projectValue = (value, maximumDepth, maximumNodes) => projectValueRecursive(value, 0, new Set(), {
+    maximumDepth,
+    maximumNodes,
+    nodes: 0,
+});
+const projectValueRecursive = (candidate, depth, ancestors, context) => {
+    context.nodes += 1;
+    if (context.nodes > context.maximumNodes || depth > context.maximumDepth)
+        throw new RangeError("Replay result projection limit exceeded");
+    const leaf = projectLeaf(candidate);
+    if (leaf !== undefined)
+        return leaf;
+    if (typeof candidate !== "object" || candidate === null)
+        throw new TypeError(`Unsupported replay result type: ${typeof candidate}`);
+    if (types.isProxy(candidate))
+        throw new TypeError("Proxy replay results are unavailable");
+    if (ancestors.has(candidate))
+        throw new TypeError("Cyclic replay result");
+    ancestors.add(candidate);
+    try {
+        assertSupportedPrototype(candidate);
+        return projectComplexValue(candidate, depth, ancestors, context);
+    }
+    finally {
+        ancestors.delete(candidate);
+    }
+};
+const projectLeaf = (candidate) => {
+    if (candidate === null ||
+        typeof candidate === "string" ||
+        typeof candidate === "boolean")
+        return candidate;
+    if (typeof candidate === "number") {
+        if (!Number.isFinite(candidate))
+            throw new TypeError("Non-finite replay result number");
+        return candidate;
+    }
+    return undefined;
+};
+const assertSupportedPrototype = (candidate) => {
+    if (Array.isArray(candidate))
+        return;
+    const prototype = Object.getPrototypeOf(candidate);
+    if (prototype !== null && Object.getPrototypeOf(prototype) !== null)
+        throw new TypeError("Unsupported replay result prototype");
+};
+const projectComplexValue = (candidate, depth, ancestors, context) => {
+    const descriptors = Object.getOwnPropertyDescriptors(candidate);
+    const output = Array.isArray(candidate)
+        ? []
+        : {};
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (key === "length" && Array.isArray(candidate))
+            continue;
+        if (!("value" in descriptor))
+            throw new TypeError("Replay result accessors are unavailable");
+        if (Array.isArray(output)) {
+            if (!/^\d+$/u.test(key))
+                throw new TypeError("Replay arrays may only contain indexed values");
+            output[Number(key)] = projectValueRecursive(descriptor.value, depth + 1, ancestors, context);
+        }
+        else {
+            output[key] = projectValueRecursive(descriptor.value, depth + 1, ancestors, context);
+        }
+    }
+    return output;
+};
+const exceptionOutcome = (replayCase, outcome, error, maximumBytes) => {
+    const details = exceptionDetails(error);
+    const name = bounded(details.name, maximumBytes);
+    const message = bounded(details.message, maximumBytes);
+    const stack = details.stack === null ? null : bounded(details.stack, maximumBytes);
+    return {
+        case_id: replayCase.caseId,
+        outcome,
+        exception: { name, message, stack },
+        input_sha256: replayCase.inputSha256,
+        output_sha256: null,
+        truncated: false,
+    };
+};
+const exceptionDetails = (error) => {
+    if (typeof error !== "object" || error === null)
+        return { name: "Error", message: "Unknown replay exception", stack: null };
+    if (types.isProxy(error))
+        return { name: "Error", message: "Proxy replay exception", stack: null };
+    const own = Object.getOwnPropertyDescriptors(error);
+    const prototype = Object.getPrototypeOf(error);
+    const inherited = prototype === null ? {} : Object.getOwnPropertyDescriptors(prototype);
+    const stringValue = (descriptor) => descriptor !== undefined &&
+        "value" in descriptor &&
+        typeof descriptor.value === "string"
+        ? descriptor.value
+        : null;
+    return {
+        name: stringValue(own.name) ?? stringValue(inherited.name) ?? "Error",
+        message: stringValue(own.message) ?? "Unknown replay exception",
+        stack: stringValue(own.stack),
+    };
+};
+const bounded = (value, maximumBytes) => {
+    const bytes = Buffer.from(value);
+    if (bytes.byteLength <= maximumBytes)
+        return value;
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    for (let end = maximumBytes; end >= Math.max(0, maximumBytes - 3); end -= 1) {
+        try {
+            return decoder.decode(bytes.subarray(0, end));
+        }
+        catch {
+            /* try the preceding UTF-8 boundary */
+        }
+    }
+    return "";
+};
+void main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Replay worker failed";
+    process.stderr.write(message.slice(0, 4096));
+    process.exitCode = 70;
+});