rea-agents 1.7.0 → 2.0.0

package/dist/application/ManagedMemberComparisonService.js

@@ -0,0 +1,122 @@
+import { readFile, stat } from "node:fs/promises";
+import { z } from "zod";
+import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../domain/managedMemberComparison.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { err, ok } from "../domain/result.js";
+import { inspectManagedMembersBytes } from "../dotnet/ManagedMemberInspector.js";
+import { MANAGED_STATIC_PROVIDER } from "./InvestigationProviders.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+/** Compare managed members from input parsed by a trusted adapter. */
+export const compareManagedMembersEvidenceValidated = (input) => {
+    const operation = "compare_managed_members";
+    try {
+        const left = parseManagedMemberEvidence(input.left);
+        const right = parseManagedMemberEvidence(input.right);
+        const result = compareManagedMembers({ evidenceId: left.evidenceId, result: left.result }, { evidenceId: right.evidenceId, result: right.result }, input.limits);
+        return ok(createManagedMemberComparisonEvidence(input, result));
+    }
+    catch (cause) {
+        return workflowFailure(operation, cause);
+    }
+};
+/** Inspect two local PE artifacts and return one derived comparison Evidence. */
+export const compareManagedMemberPaths = async (input) => {
+    const operation = "compare_managed_members";
+    try {
+        const [leftTarget, rightTarget] = await Promise.all([
+            parseBinaryTarget(input.leftPath),
+            parseBinaryTarget(input.rightPath),
+        ]);
+        if (!leftTarget.ok)
+            return err(new AnalysisInputError(operation, { cause: leftTarget.error }));
+        if (!rightTarget.ok)
+            return err(new AnalysisInputError(operation, { cause: rightTarget.error }));
+        const [leftStat, rightStat] = await Promise.all([
+            stat(leftTarget.value.path),
+            stat(rightTarget.value.path),
+        ]);
+        if (leftStat.size > input.memberLimits.maxFileBytes ||
+            rightStat.size > input.memberLimits.maxFileBytes)
+            return err(new AnalysisInputError(operation, {
+                cause: new RangeError(`Managed comparison input exceeds max_file_bytes ${String(input.memberLimits.maxFileBytes)}`),
+            }));
+        const [leftBytes, rightBytes] = await Promise.all([
+            readFile(leftTarget.value.path),
+            readFile(rightTarget.value.path),
+        ]);
+        const leftInspection = inspectManagedMembersBytes(leftBytes, leftTarget.value, input.memberLimits);
+        const rightInspection = inspectManagedMembersBytes(rightBytes, rightTarget.value, input.memberLimits);
+        const leftEvidence = createEvidence(leftTarget.value, MANAGED_STATIC_PROVIDER, {
+            operation: "inspect_managed_members",
+            parameters: memberLimitParameters(input.memberLimits),
+            result: jsonValueSchema.parse(leftInspection),
+            rawResult: null,
+            limitations: leftInspection.limitations,
+            locations: [{ kind: "artifact-path", path: leftTarget.value.path }],
+        });
+        const rightEvidence = createEvidence(rightTarget.value, MANAGED_STATIC_PROVIDER, {
+            operation: "inspect_managed_members",
+            parameters: memberLimitParameters(input.memberLimits),
+            result: jsonValueSchema.parse(rightInspection),
+            rawResult: null,
+            limitations: rightInspection.limitations,
+            locations: [{ kind: "artifact-path", path: rightTarget.value.path }],
+        });
+        const result = compareManagedMembers({
+            evidenceId: leftEvidence.evidence_id,
+            result: leftInspection,
+        }, {
+            evidenceId: rightEvidence.evidence_id,
+            result: rightInspection,
+        }, input.comparisonLimits);
+        return ok(createManagedMemberComparisonEvidence({
+            left: leftEvidence,
+            right: rightEvidence,
+            limits: input.comparisonLimits,
+        }, result));
+    }
+    catch (cause) {
+        return workflowFailure(operation, cause);
+    }
+};
+const createManagedMemberComparisonEvidence = (parameters, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-member-comparison/v1",
+    operation: "compare_managed_members",
+    parameters: {
+        left_evidence_id: parameters.left.evidence_id,
+        right_evidence_id: parameters.right.evidence_id,
+        limits: jsonValueSchema.parse(parameters.limits),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});
+const memberLimitParameters = (limits) => ({
+    type_offset: limits.typeOffset,
+    type_limit: limits.typeLimit,
+    method_offset: limits.methodOffset,
+    method_limit: limits.methodLimit,
+    field_offset: limits.fieldOffset,
+    field_limit: limits.fieldLimit,
+    member_ref_offset: limits.memberRefOffset,
+    member_ref_limit: limits.memberRefLimit,
+    edge_offset: limits.edgeOffset,
+    edge_limit: limits.edgeLimit,
+    instruction_anchor_limit: limits.instructionAnchorLimit,
+    max_file_bytes: limits.maxFileBytes,
+    max_metadata_bytes: limits.maxMetadataBytes,
+    max_table_rows: limits.maxTableRows,
+    max_heap_item_bytes: limits.maxHeapItemBytes,
+    max_method_body_bytes: limits.maxMethodBodyBytes,
+    max_method_instructions: limits.maxMethodInstructions,
+});
+const workflowFailure = (operation, cause) => err(cause instanceof z.ZodError || cause instanceof TypeError
+    ? new AnalysisInputError(operation, { cause })
+    : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause }));

package/dist/application/ManagedNativeVerificationService.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../domain/managedNativeVerification.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "verify_managed_native_boundaries";
+/** Verify managed/native boundary declarations against native Evidence. */
+export const verifyManagedNativeBoundariesEvidence = (rawInput) => {
+    const parsed = managedNativeVerificationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    try {
+        const result = verifyManagedNativeBoundaries(parsed.data);
+        return ok(createManagedNativeVerificationEvidence(parsed.data, result));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError || cause instanceof z.ZodError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed/native verification produced an invalid result", { cause }));
+    }
+};
+const createManagedNativeVerificationEvidence = (input, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-native-verification/v1",
+    operation: OPERATION,
+    parameters: {
+        managed_boundaries_evidence_id: input.managed_boundaries.evidence_id,
+        native_evidence_ids: jsonValueSchema.parse(input.native_observations.map(({ evidence_id: id }) => id)),
+        limits: jsonValueSchema.parse(input.limits),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});

package/dist/application/ManagedReconstructionService.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../domain/managedReconstruction.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "import_managed_reconstruction";
+/** Authenticate and import managed decompiler reconstruction as Evidence. */
+export const importManagedReconstructionEvidence = (rawInput) => {
+    const parsed = managedReconstructionImportInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    return importManagedReconstructionEvidenceValidated(parsed.data);
+};
+/** Import reconstruction from input parsed by a trusted adapter. */
+export const importManagedReconstructionEvidenceValidated = (input) => {
+    try {
+        const result = importManagedReconstruction(input);
+        return ok(createManagedReconstructionEvidence(input, result));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError || cause instanceof z.ZodError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed reconstruction import produced an invalid result", { cause }));
+    }
+};
+const createManagedReconstructionEvidence = (input, result) => createEvidence({
+    path: result.static_observation.artifact_path,
+    sha256: result.static_observation.artifact_sha256,
+    format: "pe",
+}, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-reconstruction-import/v1",
+    operation: OPERATION,
+    parameters: {
+        static_members_evidence_id: input.static_members.evidence_id,
+        decompiler: jsonValueSchema.parse(result.decompiler),
+        method_locks: jsonValueSchema.parse(input.methods.map(({ token, signature_sha256, normalized_il_sha256 }) => ({
+            token,
+            signature_sha256,
+            normalized_il_sha256,
+        }))),
+        notes: jsonValueSchema.parse(input.notes),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    locations: [
+        {
+            kind: "artifact-path",
+            path: result.static_observation.artifact_path,
+        },
+    ],
+    evidenceLinks: result.evidence_links,
+});

package/dist/application/ManagedRuntimeCorrelationService.js

@@ -0,0 +1,103 @@
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { createEvidence, parseEvidence, } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { managedRuntimeCorrelationInputSchema, planManagedRuntimeCorrelation, } from "../domain/managedRuntimeCorrelation.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { digestJson } from "./JavaScriptReplayPlanning.js";
+const OPERATION = "plan_managed_runtime_correlation";
+/** Create a separately authorized, non-executing managed runtime plan Evidence. */
+export const planManagedRuntimeCorrelationEvidence = async (dependencies, rawInput) => {
+    const parsed = managedRuntimeCorrelationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    return planManagedRuntimeCorrelationEvidenceValidated(dependencies, parsed.data);
+};
+/** Plan runtime correlation from input parsed by a trusted adapter. */
+export const planManagedRuntimeCorrelationEvidenceValidated = async (dependencies, input) => {
+    if (!dependencies.policy.enabled)
+        return err(new AnalysisCapabilityUnavailableError(MANAGED_WORKFLOW_PROVIDER.id, OPERATION, "managed runtime correlation is disabled; configure exact roots and runtime executable before enabling it"));
+    if (dependencies.authority === undefined)
+        return err(new AnalysisCapabilityUnavailableError(MANAGED_WORKFLOW_PROVIDER.id, OPERATION, "managed runtime permission policy is not configured"));
+    let staticEvidence;
+    let artifactPath;
+    try {
+        staticEvidence = parseEvidence(input.static_members);
+        artifactPath = artifactPathFor(staticEvidence);
+    }
+    catch (cause) {
+        return err(new AnalysisInputError(OPERATION, { cause }));
+    }
+    const authorized = await dependencies.authority.explain({
+        capability: "managed_runtime",
+        roots: [artifactPath],
+        executables: [dependencies.policy.executablePath],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: operationIdentity(input, staticEvidence),
+    }, "read", { restartRequired: true });
+    if (!authorized.ok)
+        return err(authorized.error instanceof PermissionRequiredError
+            ? authorized.error
+            : new AnalysisProtocolError(authorized.error.message, {
+                cause: authorized.error,
+            }));
+    try {
+        const result = planManagedRuntimeCorrelation(input, dependencies.policy.executablePath, authorized.value.grant_id);
+        return ok(createEvidence({
+            path: result.static_observation.artifact_path,
+            sha256: result.static_observation.artifact_sha256,
+            format: "pe",
+        }, MANAGED_WORKFLOW_PROVIDER, {
+            predicateType: "rea.managed-runtime-correlation-plan/v1",
+            operation: OPERATION,
+            parameters: {
+                static_members_evidence_id: staticEvidence.evidence_id,
+                method: jsonValueSchema.parse(input.method),
+                requested_effect: input.requested_effect,
+                host: jsonValueSchema.parse(input.host),
+                bounds: jsonValueSchema.parse(input.bounds),
+            },
+            result: jsonValueSchema.parse(result),
+            rawResult: null,
+            confidence: "derived",
+            authority: "analyst-inference",
+            environment: null,
+            limitations: result.limitations,
+            locations: [
+                {
+                    kind: "artifact-path",
+                    path: result.static_observation.artifact_path,
+                },
+            ],
+            evidenceLinks: result.evidence_links,
+        }));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed runtime correlation planning produced an invalid result", { cause }));
+    }
+};
+const artifactPathFor = (evidence) => {
+    const result = evidence.normalized_result;
+    if (typeof result === "object" &&
+        result !== null &&
+        "artifact" in result &&
+        typeof result.artifact === "object" &&
+        result.artifact !== null &&
+        "path" in result.artifact &&
+        typeof result.artifact.path === "string")
+        return result.artifact.path;
+    throw new AnalysisInputError(OPERATION, {
+        cause: new TypeError("Managed member Evidence does not expose an artifact path"),
+    });
+};
+const operationIdentity = (input, evidence) => `${OPERATION}:${digestJson({
+    evidence_id: evidence.evidence_id,
+    method: input.method,
+    requested_effect: input.requested_effect,
+    host: input.host,
+    bounds: input.bounds,
+})}`;

package/dist/application/PermissionAuthority.js

@@ -93,7 +93,7 @@ export class PermissionAuthority {
         const decision = evaluatePermission(this.policy, canonical.value);
         if (!decision.allowed)
             return err(new PermissionRequiredError(canonical.value, decision.missing, ceilingFor(this.policy, canonical.value.capability), options.elicitationSupported ?? false, options.restartRequired ?? false));
-        return ok(decision);
+        return ok({ ...decision, request: canonical.value });
     }
     /** Add authority beneath the administrator ceiling. */
     grant(grant) {

package/dist/application/ProcessSampling.js

@@ -5,15 +5,19 @@ import { readProcessRunId } from "../process/ProcessOwnership.js";
 const execFileAsync = promisify(execFile);
 const PROC_READ_CONCURRENCY = 64;
 /** Prove that forkpty completed session setup and installed the run token. */
-export const isInitializedPtyRoot = (options) => options.before.pid === options.rootPid &&
-    options.before.process_group_id === options.rootPid &&
-    options.before.session_id === options.rootPid &&
-    options.after.pid === options.rootPid &&
-    options.after.parent_pid === options.before.parent_pid &&
-    options.after.process_group_id === options.rootPid &&
-    options.after.session_id === options.rootPid &&
-    options.after.startTime === options.before.startTime &&
-    options.observedRunId === options.expectedRunId;
+export const isInitializedPtyRoot = (options) => {
+    const sessionIdentityMatches = (options.before.session_id === options.rootPid &&
+        options.after.session_id === options.rootPid) ||
+        (options.before.session_id === null && options.after.session_id === null);
+    return (options.before.pid === options.rootPid &&
+        options.before.process_group_id === options.rootPid &&
+        sessionIdentityMatches &&
+        options.after.pid === options.rootPid &&
+        options.after.parent_pid === options.before.parent_pid &&
+        options.after.process_group_id === options.rootPid &&
+        options.after.startTime === options.before.startTime &&
+        options.observedRunId === options.expectedRunId);
+};
 const isExpectedProcReadFailure = (cause) => cause instanceof Error &&
     "code" in cause &&
     (cause.code === "ENOENT" ||
@@ -215,7 +219,7 @@ const readPsRows = async (signal) => {
         pid: Number(match[1]),
         parent_pid: Number(match[2]),
         process_group_id: Number(match[3]),
-        session_id: Number(match[4]),
+        session_id: Number(match[4]) || null,
         command: match[5] ?? "",
         startTime: undefined,
     }))
@@ -232,7 +236,7 @@ const inspectInitializedPtyRoot = async (rootPid, runId, signal) => {
     const before = await readRootIdentity(rootPid, signal);
     if (before === undefined ||
         before.process_group_id !== rootPid ||
-        before.session_id !== rootPid)
+        (before.session_id !== rootPid && before.session_id !== null))
         return undefined;
     let observedRunId;
     try {

package/dist/application/ProjectPermissionStore.js

@@ -21,6 +21,7 @@ const grantSchema = z.object({
         "artifact_extract",
         "native_mount",
         "reference_read",
+        "javascript_replay",
     ]),
     roots: z.array(z.string()),
     executables: z.array(z.string()),

package/dist/application/runtime.js

@@ -3,6 +3,7 @@ import { HopperProvider } from "../hopper/HopperProvider.js";
 import { GhidraProvider } from "../ghidra/GhidraProvider.js";
 import { NativeMacOSProvider } from "../native/NativeMacOSProvider.js";
 import { ArtifactProvider } from "../artifacts/ArtifactProvider.js";
+import { ManagedStaticProvider } from "../dotnet/ManagedStaticProvider.js";
 import { silentLogger } from "../logger.js";
 import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
 import { SessionProviderRouter } from "./SessionProviderRouter.js";
@@ -17,5 +18,6 @@ export const createBinarySession = (config, logger = silentLogger) => {
     return new BinarySession(SessionProviderRouter.selectable(new AnalysisProviderRegistry([hopper, ghidra], config.analysisProvider), [
         new ArtifactProvider(config.artifactNativeMountEnabled, config.artifactIntegrityContinueEnabled),
         new NativeMacOSProvider(),
+        new ManagedStaticProvider(),
     ]));
 };

package/dist/browser/CdpCaptureEvents.js

@@ -8,6 +8,7 @@ export class CdpCaptureEvents {
     input;
     allowedOrigins;
     scripts = new Map();
+    executionContextFrames = new Map();
     network = new Map();
     allowedWebSockets = new Set();
     console = [];
@@ -36,6 +37,7 @@ export class CdpCaptureEvents {
         this.originViolation = false;
         this.navigationDuringCapture = false;
         this.scripts.clear();
+        this.executionContextFrames.clear();
         this.network.clear();
         this.allowedWebSockets.clear();
         this.console.length = 0;
@@ -62,6 +64,15 @@ export class CdpCaptureEvents {
         if (params === undefined)
             return;
         switch (event.method) {
+            case "Runtime.executionContextCreated":
+                this.#executionContext(params);
+                break;
+            case "Runtime.executionContextDestroyed":
+                this.#destroyExecutionContext(params);
+                break;
+            case "Runtime.executionContextsCleared":
+                this.executionContextFrames.clear();
+                break;
             case "Debugger.scriptParsed":
                 this.#script(params);
                 break;
@@ -91,6 +102,37 @@ export class CdpCaptureEvents {
                 break;
         }
     }
+    /** Resolve a transient execution context to one already authorized frame. */
+    frameForScript(script, allowedFrameIds) {
+        if (script.executionContextKey === null)
+            return null;
+        const frameId = this.executionContextFrames.get(script.executionContextKey);
+        return frameId !== undefined && allowedFrameIds.has(frameId)
+            ? frameId
+            : null;
+    }
+    #executionContext(params) {
+        const context = recordValue(params.context);
+        const identifier = numberValue(context?.id);
+        const frameId = stringValue(recordValue(context?.auxData)?.frameId);
+        if (identifier === undefined ||
+            !Number.isSafeInteger(identifier) ||
+            frameId === undefined ||
+            frameId.length > 256)
+            return;
+        const key = String(identifier);
+        if (this.executionContextFrames.size >= this.input.limits.max_scripts &&
+            !this.executionContextFrames.has(key)) {
+            this.completeness.truncate("scripts");
+            return;
+        }
+        this.executionContextFrames.set(key, frameId);
+    }
+    #destroyExecutionContext(params) {
+        const key = executionContextKey(params.executionContextId);
+        if (key !== null)
+            this.executionContextFrames.delete(key);
+    }
     #script(params) {
         const scriptId = stringValue(params.scriptId);
         const rawUrl = stringValue(params.url) ?? "";
@@ -120,6 +162,7 @@ export class CdpCaptureEvents {
             language: boundedText(params.scriptLanguage, 100),
             sourceMapUrl: sourceMap.sanitized,
             sourceMapRawUrl: sourceMap.raw,
+            executionContextKey: executionContextKey(params.executionContextId),
         });
     }
     #sourceMap(value, scriptUrl) {
@@ -501,6 +544,12 @@ const integerOrNull = (value) => {
     const number = numberValue(value);
     return number === undefined ? null : Math.max(0, Math.trunc(number));
 };
+const executionContextKey = (value) => {
+    const identifier = numberValue(value);
+    return identifier !== undefined && Number.isSafeInteger(identifier)
+        ? String(identifier)
+        : null;
+};
 const isJsonContentType = (headers) => {
     if (headers === undefined)
         return false;