rea-agents 2.0.0 → 2.2.0

package/dist/ghidra/GhidraSessionValues.js

@@ -36,6 +36,7 @@ const sessionInfoSchema = z
         compiler_spec_id: z.string().min(1),
         image_base: z.string().regex(/^0x[0-9a-f]+$/u),
         default_address_space: z.string().min(1),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     })
         .strict(),
 })
@@ -47,6 +48,7 @@ export const parseGhidraSessionInfo = (value, expected) => {
         parsed.data.run_id !== expected.runId ||
         parsed.data.provider.version !== expected.providerVersion ||
         parsed.data.profile_digest !== expected.profileDigest ||
+        parsed.data.target.sha256 !== expected.targetSha256 ||
         new Set(parsed.data.capabilities).size !==
             GHIDRA_SESSION_CAPABILITIES.length ||
         GHIDRA_SESSION_CAPABILITIES.some((capability) => !parsed.data.capabilities.includes(capability)) ||

package/dist/ghidra/GhidraSocketConnection.js

@@ -1,8 +1,9 @@
 import { createConnection } from "node:net";
 import { err, ok } from "../domain/result.js";
-import { GhidraSessionError } from "./GhidraSessionError.js";
+import { GhidraSessionError, } from "./GhidraSessionError.js";
+import { observeGhidraEndpoint, } from "./GhidraTransport.js";
 /** Attach decoded bridge listeners and return an idempotent detach callback. */
-export const attachGhidraSocket = (socket, handlers) => {
+const attachGhidraSocket = (socket, handlers) => {
     socket.setEncoding("utf8");
     socket.on("data", handlers.data);
     socket.on("error", handlers.error);
@@ -13,9 +14,40 @@ export const attachGhidraSocket = (socket, handlers) => {
         socket.off("close", handlers.close);
     };
 };
-/** Open one abort-aware Ghidra Unix-socket connection attempt. */
-export const connectGhidraSocketOnce = (socketPath, signal) => new Promise((resolve) => {
-    const socket = createConnection(socketPath);
+/** Poll the endpoint and attach the first ready bridge socket. */
+export const connectGhidraSocket = async (options) => {
+    while (options.deadline.remainingMs() > 0) {
+        if (options.deadline.signal.aborted)
+            return err(interruptionFailure(options));
+        if (options.isClosed())
+            return err(options.failure("cancelled", "Ghidra startup was closed"));
+        if (options.processExited())
+            return err(options.failure("process", "Ghidra exited before bridge startup"));
+        const observed = await observeGhidraEndpoint(options.endpoint);
+        if (!observed.ok)
+            return observed;
+        if (observed.value === null) {
+            if ((await options.deadline.wait(50)) === "aborted")
+                return err(interruptionFailure(options));
+            continue;
+        }
+        const connected = await connectGhidraSocketOnce(observed.value, options.deadline.signal);
+        if (connected.ok) {
+            const detach = attachGhidraSocket(connected.value, options.handlers);
+            return ok({ socket: connected.value, detach });
+        }
+        if ((await options.deadline.wait(50)) === "aborted")
+            return err(interruptionFailure(options));
+    }
+    return err(options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
+        timeoutMs: options.startupTimeoutMs,
+    }));
+};
+/** Open one abort-aware connection to an observed local Ghidra endpoint. */
+const connectGhidraSocketOnce = (target, signal) => new Promise((resolve) => {
+    const socket = "path" in target
+        ? createConnection(target.path)
+        : createConnection({ host: target.host, port: target.port });
     const detach = () => {
         socket.off("connect", onConnect);
         socket.off("error", onError);
@@ -29,14 +61,14 @@ export const connectGhidraSocketOnce = (socketPath, signal) => new Promise((reso
         detach();
         socket.destroy();
         resolve(err(new GhidraSessionError("start", "Ghidra bridge connection failed", {
-            socket_path: socketPath,
+            endpoint: target,
             error: cause.message,
         })));
     };
     const onAbort = () => {
         detach();
         socket.destroy();
-        resolve(err(new GhidraSessionError("cancelled", "Ghidra bridge connection was cancelled", { socket_path: socketPath })));
+        resolve(err(new GhidraSessionError("cancelled", "Ghidra bridge connection was cancelled", { endpoint: target })));
     };
     socket.once("connect", onConnect);
     socket.once("error", onError);
@@ -44,3 +76,8 @@ export const connectGhidraSocketOnce = (socketPath, signal) => new Promise((reso
     if (signal.aborted)
         onAbort();
 });
+const interruptionFailure = (options) => options.deadline.cancelled
+    ? options.failure("cancelled", "Ghidra startup was cancelled")
+    : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
+        timeoutMs: options.startupTimeoutMs,
+    });

package/dist/ghidra/GhidraTargetSnapshot.js

@@ -0,0 +1,30 @@
+import { createHash } from "node:crypto";
+import { constants, createReadStream } from "node:fs";
+import { chmod, copyFile, rm } from "node:fs/promises";
+import { extname, join } from "node:path";
+/** Copy one target and require its bytes to match the parsed target identity. */
+export const createGhidraTargetSnapshot = async (sourcePath, runtimeRoot, expectedSha256) => {
+    if (!/^[a-f0-9]{64}$/u.test(expectedSha256))
+        throw new TypeError("Ghidra target SHA-256 commitment is invalid");
+    const suffix = safeExtension(sourcePath);
+    const snapshotPath = join(runtimeRoot, `target-${expectedSha256.slice(0, 12)}${suffix}`);
+    try {
+        await copyFile(sourcePath, snapshotPath, constants.COPYFILE_EXCL);
+        await chmod(snapshotPath, 0o600);
+        const hash = createHash("sha256");
+        for await (const chunk of createReadStream(snapshotPath))
+            hash.update(chunk);
+        const observedSha256 = hash.digest("hex");
+        if (observedSha256 !== expectedSha256)
+            throw new Error(`Ghidra target snapshot digest mismatch: expected ${expectedSha256}, observed ${observedSha256}`);
+        return { path: snapshotPath, sha256: observedSha256 };
+    }
+    catch (cause) {
+        await rm(snapshotPath, { force: true }).catch(() => undefined);
+        throw cause;
+    }
+};
+const safeExtension = (path) => {
+    const extension = extname(path);
+    return /^\.[A-Za-z0-9]{1,12}$/u.test(extension) ? extension : ".bin";
+};

package/dist/ghidra/GhidraTransport.js

@@ -0,0 +1,71 @@
+import { access, open } from "node:fs/promises";
+import { err, ok } from "../domain/result.js";
+import { GhidraSessionError } from "./GhidraSessionError.js";
+const MAX_ENDPOINT_BYTES = 1024;
+/** Observe a ready endpoint, returning null while its bridge is not listening. */
+export const observeGhidraEndpoint = async (endpoint) => {
+    if (endpoint.transport === "unix-socket") {
+        try {
+            await access(endpoint.path);
+            return ok({ path: endpoint.path });
+        }
+        catch (cause) {
+            return isMissing(cause)
+                ? ok(null)
+                : err(endpointFailure(endpoint, "Ghidra socket observation failed", cause));
+        }
+    }
+    let handle;
+    try {
+        handle = await open(endpoint.path, "r");
+    }
+    catch (cause) {
+        return isMissing(cause)
+            ? ok(null)
+            : err(endpointFailure(endpoint, "Ghidra endpoint observation failed", cause));
+    }
+    try {
+        const bytes = Buffer.alloc(MAX_ENDPOINT_BYTES + 1);
+        const observed = await handle.read(bytes, 0, bytes.length, 0);
+        if (observed.bytesRead === 0 || observed.bytesRead > MAX_ENDPOINT_BYTES)
+            return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid"));
+        return parseTcpEndpoint(endpoint, bytes.subarray(0, observed.bytesRead).toString("utf8"));
+    }
+    catch (cause) {
+        return err(endpointFailure(endpoint, "Ghidra endpoint read failed", cause));
+    }
+    finally {
+        await handle.close();
+    }
+};
+const parseTcpEndpoint = (endpoint, encoded) => {
+    try {
+        const value = JSON.parse(encoded);
+        if (typeof value !== "object" ||
+            value === null ||
+            Array.isArray(value) ||
+            !hasExactKeys(value, ["host", "port", "schema_version"]) ||
+            value.schema_version !== 1 ||
+            value.host !== "127.0.0.1" ||
+            !Number.isSafeInteger(value.port) ||
+            typeof value.port !== "number" ||
+            value.port < 1 ||
+            value.port > 65_535)
+            return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid"));
+        return ok({ host: "127.0.0.1", port: value.port });
+    }
+    catch (cause) {
+        return err(endpointFailure(endpoint, "Ghidra TCP endpoint is invalid", cause));
+    }
+};
+const hasExactKeys = (value, expected) => {
+    const keys = Object.keys(value).sort((left, right) => left.localeCompare(right));
+    return (keys.length === expected.length &&
+        keys.every((key, index) => key === expected[index]));
+};
+const endpointFailure = (endpoint, message, cause) => new GhidraSessionError("start", message, {
+    transport: endpoint.transport,
+    endpoint_path: endpoint.path,
+    ...(cause instanceof Error ? { error: cause.message } : {}),
+}, cause instanceof Error ? { cause } : undefined);
+const isMissing = (cause) => cause instanceof Error && "code" in cause && cause.code === "ENOENT";

package/dist/identity.js

@@ -6,11 +6,13 @@
 export const PRODUCT_IDENTITY = {
     displayName: "REA",
     packageName: PACKAGE_METADATA.name,
+    packageSpecifier: `${PACKAGE_METADATA.name}@latest`,
+    registrationPackageSpecifier: `${PACKAGE_METADATA.name}@${PACKAGE_METADATA.version}`,
     packageVersion: PACKAGE_METADATA.version,
     cliBinary: "rea",
-    mcpCommand: "npx -y rea-agents mcp",
+    mcpCommand: `npx -y ${PACKAGE_METADATA.name}@${PACKAGE_METADATA.version} mcp`,
     mcpServerKey: "rea",
-    skillName: "rea-analysis",
+    skillName: "reverse-engineer-anything",
     skillVersion: PACKAGE_METADATA.skillVersion,
     configFileName: "rea.json",
 };

package/dist/main/messages.js

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,49 @@
+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;
+    let reloadQueue = Promise.resolve();
+    return (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.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;
+            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);
+        });
+    }) ?? (() => undefined));
+};

package/dist/main/shutdown.js

@@ -0,0 +1,25 @@
+import { MCP_SHUTDOWN_FAILED } from "./messages.js";
+export const createShutdown = (input) => {
+    const { handle, session, permissionAuthority, unregisterReload, dependencies, serverLogger, } = input;
+    let shutdownPromise;
+    let unregisterShutdown = () => undefined;
+    const shutdown = async () => {
+        shutdownPromise ??= (async () => {
+            unregisterReload();
+            unregisterShutdown();
+            await handle.close();
+            await session.close();
+            permissionAuthority.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);
+    return { shutdown, request: requestShutdown };
+};

package/dist/main/startup.js

@@ -0,0 +1,14 @@
+import { projectAnalysisError } from "../domain/errors.js";
+export const openInitialTarget = async (session, config, serverLogger, writeStderr) => {
+    if (config.hopperTargetPath === undefined)
+        return { ok: true };
+    const opened = await session.open(config.hopperTargetPath, {
+        targetKind: config.hopperTargetKind,
+    });
+    if (opened.ok)
+        return { ok: true };
+    await session.close();
+    serverLogger.error({ errorTag: opened.error._tag }, "Initial target failed to open");
+    writeStderr(`${projectAnalysisError(opened.error).message}\n`);
+    return { ok: false, exitCode: 1 };
+};

package/dist/main/state.js

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,61 @@
+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 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,
+                browserObservation: serverContext.browserObservation,
+                electronObservation: serverContext.electronObservation,
+                artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
+                    .artifactIntegrityContinueEnabled,
+                javascriptReplayPolicy: serverContext.runtimeState.javascriptReplayPolicy,
+                managedRuntimePolicy: serverContext.runtimeState.managedRuntimePolicy,
+                availabilityPolicy: () => ({
+                    processCaptureEnabled: serverContext.runtimeState.currentConfig.processExecutionPolicy
+                        .enabled,
+                    evidenceFileRoots: serverContext.runtimeState.currentConfig.evidenceFilePolicy
+                        .roots.length,
+                    browserObservationEnabled: serverContext.runtimeState.currentConfig
+                        .browserObservationEnabled &&
+                        serverContext.runtimeState.currentConfig.browserCdpEndpoints
+                            .length > 0 &&
+                        serverContext.runtimeState.currentConfig.browserAllowedOrigins
+                            .length > 0,
+                    electronObservationEnabled: serverContext.runtimeState.currentConfig
+                        .electronObservationEnabled &&
+                        serverContext.runtimeState.currentConfig.electronCdpEndpoints
+                            .length > 0 &&
+                        serverContext.runtimeState.currentConfig.electronFileRoots
+                            .length > 0,
+                    javascriptReplayEnabled: serverContext.runtimeState.currentConfig.javascriptReplayPolicy
+                        .enabled,
+                    managedRuntimeEnabled: serverContext.runtimeState.currentConfig.managedRuntimePolicy
+                        .enabled,
+                }),
+            });
+            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`);
+        return { ok: false };
+    }
+    return { ok: true, handle, liveServers };
+};

package/dist/main/types.js

@@ -0,0 +1 @@
+export {};

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,146 +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 runtimeJavascriptReplayPolicy = {
-        ...config.value.javascriptReplayPolicy,
-        roots: [...config.value.javascriptReplayPolicy.roots],
-    };
-    const runtimeManagedRuntimePolicy = {
-        ...config.value.managedRuntimePolicy,
-        roots: [...config.value.managedRuntimePolicy.roots],
-    };
-    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,
-                javascriptReplayPolicy: runtimeJavascriptReplayPolicy,
-                managedRuntimePolicy: runtimeManagedRuntimePolicy,
-                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,
-                    javascriptReplayEnabled: currentConfig.javascriptReplayPolicy.enabled,
-                    managedRuntimeEnabled: currentConfig.managedRuntimePolicy.enabled,
-                }),
-            });
-            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);
-            Object.assign(runtimeJavascriptReplayPolicy, refreshed.value.javascriptReplayPolicy);
-            Object.assign(runtimeManagedRuntimePolicy, refreshed.value.managedRuntimePolicy);
-            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;