rea-agents 3.2.1 → 4.0.0

package/dist/server/ProcessCaptureElicitation.js

@@ -1,153 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { acceptedContent, inputRequired, inputResponse, } from "@modelcontextprotocol/server";
-import { z } from "zod";
-import { PermissionRequiredError } from "../domain/errors.js";
-import { isPermissionRequestWithinCeiling, } from "../domain/permissionPolicy.js";
-const RESPONSE_KEY = "process_capture_grant";
-/** Shared continuation, replay, and round limits for process capture consent. */
-export const PROCESS_CAPTURE_ELICITATION_POLICY = {
-    protocolVersions: ["2026-07-28"],
-    stateTtlSeconds: 600,
-    roundTimeoutMs: 600_000,
-    maxConsumedNonces: 4_096,
-};
-const grantResponseSchema = z.strictObject({
-    lifetime: z.enum(["once", "session"]).meta({ default: "session" }),
-});
-const grantResponseJsonSchema = { ...z.toJSONSchema(grantResponseSchema) };
-// MCP elicitation accepts a reduced JSON Schema subset. These generator
-// annotations do not change the schema's fields or validation semantics; the
-// Standard Schema marker would make the SDK regenerate the removed keywords.
-Reflect.deleteProperty(grantResponseJsonSchema, "$schema");
-Reflect.deleteProperty(grantResponseJsonSchema, "additionalProperties");
-const stateSchema = z.strictObject({
-    nonce: z.string().uuid(),
-    request: z.strictObject({
-        capability: z.literal("process_capture"),
-        roots: z.array(z.string()),
-        executables: z.array(z.string()),
-        environment_names: z.array(z.string()),
-        origins: z.array(z.string()).optional(),
-        network: z.enum(["none", "loopback", "external"]),
-        mount: z.boolean(),
-        operation_identity: z.string(),
-    }),
-});
-/** Authorize capture or return a signed MCP input-required continuation. */
-export const authorizeProcessCaptureWithElicitation = async (authority, request, context, elicitation) => {
-    const initial = await authority.authorize(request, "read", {
-        remediation: elicitation.supported(context) ? "elicit" : "configure",
-    });
-    if (initial.ok || !(initial.error instanceof PermissionRequiredError))
-        return initial;
-    const denied = initial.error;
-    if (denied.remediation !== "elicit" ||
-        denied.requested.capability !== "process_capture" ||
-        denied.ceiling === null ||
-        !isPermissionRequestWithinCeiling(denied.requested, denied.ceiling))
-        return initial;
-    const encodedState = context.mcpReq.requestState();
-    if (encodedState !== undefined) {
-        const state = stateSchema.safeParse(encodedState);
-        if (!state.success || !sameRequest(state.data.request, denied.requested))
-            return initial;
-        const response = inputResponse(context.mcpReq.inputResponses, RESPONSE_KEY);
-        if (response.kind === "elicit") {
-            if (!consumeNonce(elicitation.consumedNonces, state.data.nonce, elicitation.now()))
-                return initial;
-        }
-        if (response.kind === "elicit" && response.action === "accept") {
-            const content = acceptedContent(context.mcpReq.inputResponses, RESPONSE_KEY, grantResponseSchema);
-            if (content === undefined)
-                return initial;
-            return grantAndAuthorize(authority, state.data.request, content.lifetime);
-        }
-        if (response.kind === "elicit" &&
-            (response.action === "decline" || response.action === "cancel"))
-            return initial;
-    }
-    const state = await elicitation.stateCodec.mint({
-        nonce: randomUUID(),
-        request: {
-            capability: "process_capture",
-            roots: [...denied.requested.roots],
-            executables: [...denied.requested.executables],
-            environment_names: [...denied.requested.environment_names],
-            network: denied.requested.network,
-            mount: denied.requested.mount,
-            operation_identity: denied.requested.operation_identity,
-            ...(denied.requested.origins === undefined
-                ? {}
-                : { origins: [...denied.requested.origins] }),
-        },
-    });
-    return inputRequired({
-        inputRequests: {
-            [RESPONSE_KEY]: inputRequired.elicit({
-                message: permissionMessage(denied.requested),
-                requestedSchema: grantResponseJsonSchema,
-            }),
-        },
-        requestState: state,
-    });
-};
-const grantAndAuthorize = async (authority, request, lifetime) => {
-    const grant = {
-        ...request,
-        grant_id: `elicited:${randomUUID()}`,
-        lifetime,
-        operation_identity: lifetime === "once" ? request.operation_identity : null,
-        expires_at: null,
-    };
-    const granted = authority.grant(grant);
-    if (!granted.ok)
-        return authority.authorize(request, "read", {
-            remediation: "elicit",
-        });
-    let authorized;
-    try {
-        authorized = await authority.authorize(request, "read", {
-            remediation: "elicit",
-        });
-    }
-    catch (cause) {
-        authority.revoke(grant.grant_id);
-        throw cause;
-    }
-    if (!authorized.ok)
-        authority.revoke(grant.grant_id);
-    return authorized;
-};
-const sameRequest = (left, right) => left.capability === right.capability &&
-    left.network === right.network &&
-    left.mount === right.mount &&
-    left.operation_identity === right.operation_identity &&
-    sameOptionalStrings(left.origins, right.origins) &&
-    sameStrings(left.roots, right.roots) &&
-    sameStrings(left.executables, right.executables) &&
-    sameStrings(left.environment_names, right.environment_names);
-const sameStrings = (left, right) => left.length === right.length &&
-    left.every((value, index) => value === right[index]);
-const sameOptionalStrings = (left, right) => left === undefined
-    ? right === undefined
-    : right !== undefined && sameStrings(left, right);
-const consumeNonce = (consumed, nonce, now) => {
-    for (const [candidate, expiresAt] of consumed)
-        if (expiresAt <= now)
-            consumed.delete(candidate);
-    if (consumed.has(nonce) ||
-        consumed.size >= PROCESS_CAPTURE_ELICITATION_POLICY.maxConsumedNonces)
-        return false;
-    consumed.set(nonce, now + PROCESS_CAPTURE_ELICITATION_POLICY.stateTtlSeconds * 1_000);
-    return true;
-};
-const permissionMessage = (request) => [
-    "Allow REA to run this exact process-capture scope?",
-    `Executable: ${request.executables.join(", ") || "none"}`,
-    `Filesystem roots: ${request.roots.join(", ") || "none"}`,
-    `Environment names: ${request.environment_names.join(", ") || "none"}`,
-    `Origins: ${request.origins?.join(", ") || "none"}`,
-    `Network: ${request.network}`,
-    `Mount access: ${request.mount ? "yes" : "no"}`,
-    "Choose whether the grant applies once or for this MCP session.",
-].join("\n");

package/dist/server/registerApplicationTools/characterization.js

@@ -1,46 +0,0 @@
-import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
-import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { parseEvidence } from "../../domain/evidence.js";
-import { nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
-import { logToolExecution } from "../toolLogging.js";
-import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
-const prepareContract = applicationToolContract("prepare_node_characterization");
-const executeContract = applicationToolContract("execute_node_characterization");
-/** Register node runtime characterization prepare and execute tools. */
-export const registerCharacterizationTools = (server, options) => {
-    server.registerTool(prepareContract.name, toolRegistrationOptions(prepareContract), async (input, context) => {
-        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, input, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, prepareContract);
-        const output = nodeCharacterizationPreparationOutputSchema.parse(result.value);
-        const recorded = options.recordEvidence?.(parseEvidence(output.transformation_evidence));
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, prepareContract);
-        return toCallToolResult(result, prepareContract);
-    });
-    server.registerTool(executeContract.name, toolRegistrationOptions(executeContract), async (input, context) => {
-        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, input, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, executeContract);
-        const output = nodeCharacterizationExecutionOutputSchema.parse(result.value);
-        const sources = [
-            output.transformation_evidence,
-            ...output.replay.source_evidence,
-            output.replay.evidence,
-            output.evidence,
-        ].map((item) => parseEvidence(item));
-        const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
-        if (!recorded.ok)
-            return toCallToolResult(recorded, executeContract);
-        return toCallToolResult(result, executeContract);
-    });
-};

package/dist/server/registerApplicationTools/controlledReplay.js

@@ -1,31 +0,0 @@
-import { recordSessionEvidenceSources } from "../sessionEvidence.js";
-import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
-import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { parseEvidence } from "../../domain/evidence.js";
-import { controlledReplayOutputSchema } from "../../domain/javascriptReplay.js";
-import { mcpProgressReporter } from "../mcpProgress.js";
-import { logToolExecution } from "../toolLogging.js";
-import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
-const replayContract = applicationToolContract("run_controlled_replay");
-/** Register the controlled JavaScript replay tool. */
-export const registerControlledReplayTool = (server, options) => {
-    server.registerTool(replayContract.name, toolRegistrationOptions(replayContract), async (input, context) => {
-        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, input, {
-            signal: context.mcpReq.signal,
-            progress: mcpProgressReporter(context),
-        }));
-        if (!result.ok)
-            return toCallToolResult(result, replayContract);
-        const output = controlledReplayOutputSchema.parse(result.value);
-        if (output.phase === "execute") {
-            const sourcesRecorded = recordSessionEvidenceSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
-            if (!sourcesRecorded.ok)
-                return toCallToolResult(sourcesRecorded, replayContract);
-            const recorded = options.recordEvidence?.(parseEvidence(output.evidence));
-            if (recorded !== undefined && !recorded.ok)
-                return toCallToolResult(recorded, replayContract);
-        }
-        return toCallToolResult(result, replayContract);
-    });
-};

package/dist/server/registerManagedWorkflowTools/planManagedRuntimeCorrelation.js

@@ -1,29 +0,0 @@
-import { planManagedRuntimeCorrelationEvidenceValidated } from "../../application/ManagedRuntimeCorrelationService.js";
-import { logToolExecution } from "../toolLogging.js";
-import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
-import { managedWorkflowContract } from "./contract.js";
-import { resolveManagedEvidence } from "./evidence.js";
-const runtimeContract = managedWorkflowContract("plan_managed_runtime_correlation");
-/** Register the managed runtime correlation planning workflow tool. */
-export const registerPlanManagedRuntimeCorrelation = (server, options) => {
-    server.registerTool(runtimeContract.name, toolRegistrationOptions(runtimeContract), async (input) => {
-        const resolved = resolveManagedEvidence(input.static_members);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, runtimeContract);
-        const staticMembers = resolved.value[0];
-        if (staticMembers === undefined)
-            throw new TypeError("Managed runtime Evidence resolution failed");
-        const parsed = { ...input, static_members: staticMembers };
-        const result = await logToolExecution(options.logger, runtimeContract.name, () => Promise.resolve(planManagedRuntimeCorrelationEvidenceValidated(options.runtime, parsed)));
-        if (!result.ok)
-            return toCallToolResult(result, runtimeContract);
-        const recordedSource = options.recordEvidence?.(parsed.static_members);
-        if (recordedSource !== undefined && !recordedSource.ok)
-            return toCallToolResult(recordedSource, runtimeContract);
-        const recorded = options.recordEvidence?.(result.value);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, runtimeContract);
-        return toCallToolResult(result, runtimeContract);
-    });
-};

package/dist/server/registerReplayMachineTool.js

@@ -1,14 +0,0 @@
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { runReplayMachine } from "../domain/replayMachineRun.js";
-import { ok } from "../domain/result.js";
-import { logToolExecution } from "./toolLogging.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
-const contract = SESSION_TOOL_CONTRACTS[18];
-/** Register direct execution-free finite replay-machine evaluation. */
-export const registerReplayMachineTool = (server, logger) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(input))));
-        return toCallToolResult(result, contract);
-    });
-};

package/skills/reverse-engineer-anything/references/controlled-replay.md

@@ -1,12 +0,0 @@
-# Controlled JavaScript replay
-
-Use `run_controlled_replay` only for operator-selected extracted modules when
-the separate replay policy is enabled. Call `mode: plan` first. Review the exact
-module, stub, runtime, sandbox, case, limits, and policy commitments. Execute
-only with `approved: true` and that exact plan digest.
-
-Treat return values, exceptions, denials, limits, and crashes as observations of
-the isolated experiment with controlled-replay authority, not facts about the
-real application. Never substitute browser/Electron permission, process
-capture, or an in-process `vm` run. Reproducer export requires separate literal
-approval and evidence-write authority after sandbox cleanup.