rea-agents 2.5.0 → 3.1.0

package/dist/config/javascriptReplay.js

@@ -0,0 +1,41 @@
+import { ConfigurationError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { parseAbsoluteRoots } from "./parsers.js";
+import { permissionScope } from "./permissions.js";
+/** Parse controlled replay configuration into disabled or fully enabled state. */
+export const parseJavaScriptReplayPolicy = (env) => {
+    const roots = parseAbsoluteRoots(env.REA_JAVASCRIPT_REPLAY_ROOTS_JSON, "REA_JAVASCRIPT_REPLAY_ROOTS_JSON");
+    if (!roots.ok)
+        return roots;
+    if (env.REA_JAVASCRIPT_REPLAY_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const [firstRoot, ...remainingRoots] = roots.value;
+    if (firstRoot === undefined)
+        return err(new ConfigurationError("REA_JAVASCRIPT_REPLAY_ROOTS_JSON must encode at least one absolute root when JavaScript replay is enabled"));
+    return ok({
+        status: "enabled",
+        roots: [firstRoot, ...remainingRoots],
+        nodePath: env.REA_JAVASCRIPT_REPLAY_NODE_PATH,
+        bubblewrapPath: env.REA_JAVASCRIPT_REPLAY_BWRAP_PATH,
+        systemdRunPath: env.REA_JAVASCRIPT_REPLAY_SYSTEMD_RUN_PATH,
+        systemctlPath: env.REA_JAVASCRIPT_REPLAY_SYSTEMCTL_PATH,
+        shellPath: env.REA_JAVASCRIPT_REPLAY_SHELL_PATH,
+    });
+};
+/** Add the exact controlled replay ceiling when replay is enabled. */
+export const appendJavaScriptReplayCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    ceilings.push(permissionScope("javascript_replay", policy.roots, {
+        executables: replayExecutables(policy),
+        network: "none",
+        mount: true,
+    }));
+};
+const replayExecutables = (policy) => [
+    policy.nodePath,
+    policy.bubblewrapPath,
+    policy.systemdRunPath,
+    policy.systemctlPath,
+    policy.shellPath,
+];

package/dist/config/managedRuntime.js

@@ -0,0 +1,25 @@
+import { ConfigurationError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { permissionScope } from "./permissions.js";
+/** Parse managed runtime correlation into a closed disabled or enabled policy. */
+export const parseManagedRuntimePolicy = (env, roots) => {
+    if (env.REA_MANAGED_RUNTIME_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const [firstRoot, ...remainingRoots] = roots;
+    if (firstRoot === undefined)
+        return err(new ConfigurationError("REA_MANAGED_RUNTIME_ROOTS_JSON must encode at least one absolute root when managed runtime correlation is enabled"));
+    return ok({
+        status: "enabled",
+        roots: [firstRoot, ...remainingRoots],
+        executablePath: env.REA_MANAGED_RUNTIME_EXECUTABLE_PATH,
+    });
+};
+/** Add the separately permissioned, no-network managed runtime ceiling. */
+export const appendManagedRuntimeCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    ceilings.push(permissionScope("managed_runtime", policy.roots, {
+        executables: [policy.executablePath],
+        network: "none",
+    }));
+};

package/dist/config/parseConfig.js

@@ -1,10 +1,14 @@
-import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
+import { ok } from "../domain/result.js";
 import { parseEnvironment } from "./environment.js";
-import { parseStringArray, parseBrowserArray, parseElectronFileRoots, parseLoaderArgs, } from "./parsers.js";
-import { filePolicy, permissionScope, administratorGrants, browserNetworkScope, } from "./permissions.js";
-import { browserEndpointSchema, browserOriginSchema, } from "../domain/browserObservation.js";
+import { parseStringArray, parseAbsoluteRoots, parseLoaderArgs, } from "./parsers.js";
+import { filePolicy, permissionScope, administratorGrants, } from "./permissions.js";
+import { appendElectronAutomationCeiling, parseElectronAutomationPolicy, } from "./electronAutomation.js";
+import { appendBrowserScenarioCeiling, parseBrowserScenarioPolicy, } from "./browserScenario.js";
+import { appendManagedRuntimeCeiling, parseManagedRuntimePolicy, } from "./managedRuntime.js";
+import { appendJavaScriptReplayCeiling, parseJavaScriptReplayPolicy, } from "./javascriptReplay.js";
+import { appendProcessCaptureCeiling, parseProcessExecutionPolicy, } from "./processCapture.js";
+import { appendPassiveObservationCeilings, parsePassiveObservationPolicies, } from "./passiveObservation.js";
 const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
 const defaultHopperLauncherPath = () => process.platform === "linux"
     ? "/opt/hopper/bin/Hopper"
@@ -13,15 +17,6 @@ const parseAllArrays = (env) => {
     const loaderArgs = parseLoaderArgs(env.HOPPER_LOADER_ARGS_JSON);
     if (!loaderArgs.ok)
         return loaderArgs;
-    const executableRoots = parseStringArray(env.REA_PROCESS_EXECUTABLE_ROOTS_JSON, "REA_PROCESS_EXECUTABLE_ROOTS_JSON");
-    if (!executableRoots.ok)
-        return executableRoots;
-    const workingRoots = parseStringArray(env.REA_PROCESS_WORKING_ROOTS_JSON, "REA_PROCESS_WORKING_ROOTS_JSON");
-    if (!workingRoots.ok)
-        return workingRoots;
-    const allowedEnvironment = parseStringArray(env.REA_PROCESS_ALLOWED_ENV_JSON, "REA_PROCESS_ALLOWED_ENV_JSON");
-    if (!allowedEnvironment.ok)
-        return allowedEnvironment;
     const evidenceRoots = parseStringArray(env.REA_EVIDENCE_ROOTS_JSON, "REA_EVIDENCE_ROOTS_JSON");
     if (!evidenceRoots.ok)
         return evidenceRoots;
@@ -37,160 +32,24 @@ const parseAllArrays = (env) => {
     const secretPatterns = parseStringArray(env.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
     if (!secretPatterns.ok)
         return secretPatterns;
-    const observations = parseObservationArrays(env);
-    if (!observations.ok)
-        return observations;
-    const javascriptReplayRoots = parseAbsoluteRoots(env.REA_JAVASCRIPT_REPLAY_ROOTS_JSON, "REA_JAVASCRIPT_REPLAY_ROOTS_JSON");
-    if (!javascriptReplayRoots.ok)
-        return javascriptReplayRoots;
     const managedRuntimeRoots = parseAbsoluteRoots(env.REA_MANAGED_RUNTIME_ROOTS_JSON, "REA_MANAGED_RUNTIME_ROOTS_JSON");
     if (!managedRuntimeRoots.ok)
         return managedRuntimeRoots;
     return ok({
         loaderArgs: loaderArgs.value,
-        executableRoots: executableRoots.value,
-        workingRoots: workingRoots.value,
-        allowedEnvironment: allowedEnvironment.value,
         evidenceRoots: evidenceRoots.value,
         investigationInputRoots: investigationInputRoots.value,
         analysisSnapshotRoots: analysisSnapshotRoots.value,
         referenceRoots: referenceRoots.value,
         secretPatterns: secretPatterns.value,
-        ...observations.value,
-        javascriptReplayRoots: javascriptReplayRoots.value,
         managedRuntimeRoots: managedRuntimeRoots.value,
     });
 };
-const parseObservationArrays = (env) => {
-    const browserEndpoints = parseBrowserArray(env.REA_BROWSER_CDP_ENDPOINTS_JSON, "REA_BROWSER_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!browserEndpoints.ok)
-        return browserEndpoints;
-    const browserOrigins = parseBrowserArray(env.REA_BROWSER_ALLOWED_ORIGINS_JSON, "REA_BROWSER_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
-    if (!browserOrigins.ok)
-        return browserOrigins;
-    const browserScenarioExecutableRoots = parseAbsoluteRoots(env.REA_BROWSER_SCENARIO_EXECUTABLE_ROOTS_JSON, "REA_BROWSER_SCENARIO_EXECUTABLE_ROOTS_JSON");
-    if (!browserScenarioExecutableRoots.ok)
-        return browserScenarioExecutableRoots;
-    const browserScenarioEndpoints = parseBrowserArray(env.REA_BROWSER_SCENARIO_CDP_ENDPOINTS_JSON, "REA_BROWSER_SCENARIO_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!browserScenarioEndpoints.ok)
-        return browserScenarioEndpoints;
-    const browserScenarioOrigins = parseBrowserArray(env.REA_BROWSER_SCENARIO_ALLOWED_ORIGINS_JSON, "REA_BROWSER_SCENARIO_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
-    if (!browserScenarioOrigins.ok)
-        return browserScenarioOrigins;
-    const browserScenarioEnvironment = parseStringArray(env.REA_BROWSER_SCENARIO_ALLOWED_ENV_JSON, "REA_BROWSER_SCENARIO_ALLOWED_ENV_JSON");
-    if (!browserScenarioEnvironment.ok)
-        return browserScenarioEnvironment;
-    const electronEndpoints = parseBrowserArray(env.REA_ELECTRON_CDP_ENDPOINTS_JSON, "REA_ELECTRON_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!electronEndpoints.ok)
-        return electronEndpoints;
-    const electronFileRoots = parseElectronFileRoots(env.REA_ELECTRON_FILE_ROOTS_JSON);
-    if (!electronFileRoots.ok)
-        return electronFileRoots;
-    const v8InspectorEndpoints = parseBrowserArray(env.REA_V8_INSPECTOR_ENDPOINTS_JSON, "REA_V8_INSPECTOR_ENDPOINTS_JSON", browserEndpointSchema, 16);
-    if (!v8InspectorEndpoints.ok)
-        return v8InspectorEndpoints;
-    const v8InspectorFileRoots = parseAbsoluteRoots(env.REA_V8_INSPECTOR_FILE_ROOTS_JSON, "REA_V8_INSPECTOR_FILE_ROOTS_JSON");
-    if (!v8InspectorFileRoots.ok)
-        return v8InspectorFileRoots;
-    const v8InspectorOrigins = parseBrowserArray(env.REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON, "REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
-    if (!v8InspectorOrigins.ok)
-        return v8InspectorOrigins;
-    return ok({
-        browserEndpoints: browserEndpoints.value,
-        browserOrigins: browserOrigins.value,
-        browserScenarioExecutableRoots: browserScenarioExecutableRoots.value,
-        browserScenarioEndpoints: browserScenarioEndpoints.value,
-        browserScenarioOrigins: browserScenarioOrigins.value,
-        browserScenarioEnvironment: browserScenarioEnvironment.value,
-        electronEndpoints: electronEndpoints.value,
-        electronFileRoots: electronFileRoots.value,
-        v8InspectorEndpoints: v8InspectorEndpoints.value,
-        v8InspectorFileRoots: v8InspectorFileRoots.value,
-        v8InspectorOrigins: v8InspectorOrigins.value,
-    });
-};
-const parseAbsoluteRoots = (value, name) => {
-    const parsed = parseStringArray(value, name);
-    if (!parsed.ok)
-        return parsed;
-    return parsed.value.some((root) => !isAbsolute(root))
-        ? err(new ConfigurationError(`${name} must encode absolute roots`))
-        : parsed;
-};
-const appendProcessCaptureCeiling = (ceilings, env, arrays) => {
-    if (env.REA_PROCESS_CAPTURE_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("process_capture", arrays.workingRoots, {
-        executables: arrays.executableRoots,
-        environment_names: arrays.allowedEnvironment,
-        network: env.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true" ? "external" : "none",
-    }));
-};
-const appendBrowserObservationCeiling = (ceilings, env, arrays) => {
-    if (env.REA_BROWSER_OBSERVE_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("browser_observe", [], {
-        origins: [...arrays.browserEndpoints, ...arrays.browserOrigins],
-        network: browserNetworkScope(arrays.browserOrigins),
-    }));
-};
-const appendBrowserScenarioCeiling = (ceilings, env, arrays) => {
-    if (env.REA_BROWSER_SCENARIO_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("browser_automate", [], {
-        executables: arrays.browserScenarioExecutableRoots,
-        environment_names: arrays.browserScenarioEnvironment,
-        origins: [
-            ...arrays.browserScenarioEndpoints,
-            ...arrays.browserScenarioOrigins,
-        ],
-        network: browserNetworkScope(arrays.browserScenarioOrigins),
-    }));
-};
-const appendElectronObservationCeiling = (ceilings, env, arrays) => {
-    if (env.REA_ELECTRON_OBSERVE_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("electron_observe", arrays.electronFileRoots, {
-        origins: arrays.electronEndpoints,
-        network: "loopback",
-    }));
-};
-const appendV8InspectorObservationCeiling = (ceilings, env, arrays) => {
-    if (env.REA_V8_INSPECTOR_OBSERVE_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("v8_inspector_observe", arrays.v8InspectorFileRoots, {
-        origins: [...arrays.v8InspectorEndpoints, ...arrays.v8InspectorOrigins],
-        network: "loopback",
-    }));
-};
 const appendNativeMountCeiling = (ceilings, env) => {
     if (env.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true")
         ceilings.push(permissionScope("native_mount", [], { mount: true }));
 };
-const appendJavaScriptReplayCeiling = (ceilings, env, arrays) => {
-    if (env.REA_JAVASCRIPT_REPLAY_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("javascript_replay", arrays.javascriptReplayRoots, {
-        executables: [
-            env.REA_JAVASCRIPT_REPLAY_NODE_PATH,
-            env.REA_JAVASCRIPT_REPLAY_BWRAP_PATH,
-            env.REA_JAVASCRIPT_REPLAY_SYSTEMD_RUN_PATH,
-            env.REA_JAVASCRIPT_REPLAY_SYSTEMCTL_PATH,
-            env.REA_JAVASCRIPT_REPLAY_SHELL_PATH,
-        ],
-        network: "none",
-        mount: true,
-    }));
-};
-const appendManagedRuntimeCeiling = (ceilings, env, arrays) => {
-    if (env.REA_MANAGED_RUNTIME_ENABLED !== "true")
-        return;
-    ceilings.push(permissionScope("managed_runtime", arrays.managedRuntimeRoots, {
-        executables: [env.REA_MANAGED_RUNTIME_EXECUTABLE_PATH],
-        network: "none",
-    }));
-};
-const buildPermissionCeilings = (env, arrays) => {
+const buildPermissionCeilings = (env, arrays, policies) => {
     const ceilings = [
         permissionScope("evidence_read", arrays.evidenceRoots),
         permissionScope("evidence_write", arrays.evidenceRoots),
@@ -202,17 +61,16 @@ const buildPermissionCeilings = (env, arrays) => {
         permissionScope("artifact_extract", ["/"]),
         permissionScope("reference_read", arrays.referenceRoots),
     ];
-    appendProcessCaptureCeiling(ceilings, env, arrays);
-    appendBrowserObservationCeiling(ceilings, env, arrays);
-    appendBrowserScenarioCeiling(ceilings, env, arrays);
-    appendElectronObservationCeiling(ceilings, env, arrays);
-    appendV8InspectorObservationCeiling(ceilings, env, arrays);
+    appendProcessCaptureCeiling(ceilings, policies.processCapture);
+    appendPassiveObservationCeilings(ceilings, policies.passiveObservation);
+    appendBrowserScenarioCeiling(ceilings, policies.browserScenario);
+    appendElectronAutomationCeiling(ceilings, policies.electronAutomation);
     appendNativeMountCeiling(ceilings, env);
-    appendJavaScriptReplayCeiling(ceilings, env, arrays);
-    appendManagedRuntimeCeiling(ceilings, env, arrays);
+    appendJavaScriptReplayCeiling(ceilings, policies.javascriptReplay);
+    appendManagedRuntimeCeiling(ceilings, policies.managedRuntime);
     return ceilings;
 };
-const buildAppConfig = (env, arrays, permissionCeilings) => ({
+const buildAppConfig = (env, arrays, permissionCeilings, policies) => ({
     analysisProvider: env.REA_ANALYSIS_PROVIDER,
     ghidraInstallDir: env.GHIDRA_INSTALL_DIR,
     ghidraJavaHome: env.JAVA_HOME,
@@ -222,13 +80,7 @@ const buildAppConfig = (env, arrays, permissionCeilings) => ({
     hopperTargetKind: env.HOPPER_TARGET_KIND,
     hopperLoaderArgs: arrays.loaderArgs,
     logLevel: env.REA_LOG_LEVEL,
-    processExecutionPolicy: {
-        enabled: env.REA_PROCESS_CAPTURE_ENABLED === "true",
-        executableRoots: arrays.executableRoots,
-        workingRoots: arrays.workingRoots,
-        allowedEnvironment: arrays.allowedEnvironment,
-        allowExternalNetwork: env.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
-    },
+    processExecutionPolicy: policies.processCapture,
     artifactNativeMountEnabled: env.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true",
     artifactIntegrityContinueEnabled: env.REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED === "true",
     evidenceFilePolicy: filePolicy(arrays.evidenceRoots),
@@ -242,42 +94,20 @@ const buildAppConfig = (env, arrays, permissionCeilings) => ({
         maxDepth: 32,
         maxPathBytes: 4_096,
     },
-    browserObservationEnabled: env.REA_BROWSER_OBSERVE_ENABLED === "true",
-    browserCdpEndpoints: arrays.browserEndpoints,
-    browserAllowedOrigins: arrays.browserOrigins,
-    browserScenarioPolicy: {
-        enabled: env.REA_BROWSER_SCENARIO_ENABLED === "true",
-        executableRoots: arrays.browserScenarioExecutableRoots,
-        cdpEndpoints: arrays.browserScenarioEndpoints,
-        allowedOrigins: arrays.browserScenarioOrigins,
-        allowedEnvironment: arrays.browserScenarioEnvironment,
-    },
-    electronObservationEnabled: env.REA_ELECTRON_OBSERVE_ENABLED === "true",
-    electronCdpEndpoints: arrays.electronEndpoints,
-    electronFileRoots: arrays.electronFileRoots,
-    v8InspectorObservationEnabled: env.REA_V8_INSPECTOR_OBSERVE_ENABLED === "true",
-    v8InspectorEndpoints: arrays.v8InspectorEndpoints,
-    v8InspectorFileRoots: arrays.v8InspectorFileRoots,
-    v8InspectorAllowedOrigins: arrays.v8InspectorOrigins,
-    javascriptReplayPolicy: {
-        enabled: env.REA_JAVASCRIPT_REPLAY_ENABLED === "true",
-        roots: arrays.javascriptReplayRoots,
-        nodePath: env.REA_JAVASCRIPT_REPLAY_NODE_PATH,
-        bubblewrapPath: env.REA_JAVASCRIPT_REPLAY_BWRAP_PATH,
-        systemdRunPath: env.REA_JAVASCRIPT_REPLAY_SYSTEMD_RUN_PATH,
-        systemctlPath: env.REA_JAVASCRIPT_REPLAY_SYSTEMCTL_PATH,
-        shellPath: env.REA_JAVASCRIPT_REPLAY_SHELL_PATH,
-    },
-    managedRuntimePolicy: {
-        enabled: env.REA_MANAGED_RUNTIME_ENABLED === "true",
-        roots: arrays.managedRuntimeRoots,
-        executablePath: env.REA_MANAGED_RUNTIME_EXECUTABLE_PATH,
-    },
+    browserObservationPolicy: policies.passiveObservation.browser,
+    browserScenarioPolicy: policies.browserScenario,
+    electronObservationPolicy: policies.passiveObservation.electron,
+    electronAutomationPolicy: policies.electronAutomation,
+    v8InspectorObservationPolicy: policies.passiveObservation.v8Inspector,
+    javascriptReplayPolicy: policies.javascriptReplay,
+    managedRuntimePolicy: policies.managedRuntime,
     permissionCeilings,
     administratorPermissionGrants: administratorGrants(permissionCeilings.filter(({ capability }) => (capability !== "process_capture" ||
         env.REA_PROCESS_CAPTURE_AUTO_GRANT === "true") &&
         (capability !== "browser_automate" ||
-            env.REA_BROWSER_SCENARIO_AUTO_GRANT === "true"))),
+            env.REA_BROWSER_SCENARIO_AUTO_GRANT === "true") &&
+        (capability !== "electron_automate" ||
+            env.REA_ELECTRON_AUTOMATE_AUTO_GRANT === "true"))),
     permissionProjectRoot: env.REA_PERMISSION_PROJECT_ROOT,
     permissionProjectStore: env.REA_PERMISSION_PROJECT_STORE,
 });
@@ -294,6 +124,32 @@ export const parseConfig = (environment) => {
     const arraysResult = parseAllArrays(envResult.value);
     if (!arraysResult.ok)
         return arraysResult;
-    const permissionCeilings = buildPermissionCeilings(envResult.value, arraysResult.value);
-    return ok(buildAppConfig(envResult.value, arraysResult.value, permissionCeilings));
+    const passiveObservationPolicies = parsePassiveObservationPolicies(envResult.value);
+    if (!passiveObservationPolicies.ok)
+        return passiveObservationPolicies;
+    const processCapturePolicy = parseProcessExecutionPolicy(envResult.value);
+    if (!processCapturePolicy.ok)
+        return processCapturePolicy;
+    const browserScenarioPolicy = parseBrowserScenarioPolicy(envResult.value);
+    if (!browserScenarioPolicy.ok)
+        return browserScenarioPolicy;
+    const electronAutomationPolicy = parseElectronAutomationPolicy(envResult.value);
+    if (!electronAutomationPolicy.ok)
+        return electronAutomationPolicy;
+    const javascriptReplayPolicy = parseJavaScriptReplayPolicy(envResult.value);
+    if (!javascriptReplayPolicy.ok)
+        return javascriptReplayPolicy;
+    const managedRuntimePolicy = parseManagedRuntimePolicy(envResult.value, arraysResult.value.managedRuntimeRoots);
+    if (!managedRuntimePolicy.ok)
+        return managedRuntimePolicy;
+    const policies = {
+        passiveObservation: passiveObservationPolicies.value,
+        processCapture: processCapturePolicy.value,
+        browserScenario: browserScenarioPolicy.value,
+        electronAutomation: electronAutomationPolicy.value,
+        javascriptReplay: javascriptReplayPolicy.value,
+        managedRuntime: managedRuntimePolicy.value,
+    };
+    const permissionCeilings = buildPermissionCeilings(envResult.value, arraysResult.value, policies);
+    return ok(buildAppConfig(envResult.value, arraysResult.value, permissionCeilings, policies));
 };

package/dist/config/parsers.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
+import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import {} from "../domain/browserObservation.js";
 import { electronFileRootsSchema } from "../domain/electronObservation.js";
 export const parseStringArray = (encoded, name) => {
     try {
@@ -19,6 +19,15 @@ export const parseStringArray = (encoded, name) => {
         return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
     }
 };
+/** Parse a JSON string array whose members must all be absolute paths. */
+export const parseAbsoluteRoots = (encoded, name) => {
+    const parsed = parseStringArray(encoded, name);
+    if (!parsed.ok)
+        return parsed;
+    return parsed.value.some((root) => !isAbsolute(root))
+        ? err(new ConfigurationError(`${name} must encode absolute roots`))
+        : parsed;
+};
 export const parseBrowserArray = (encoded, name, itemSchema, maximum) => {
     try {
         const parsed = z

package/dist/config/passiveObservation.js

@@ -0,0 +1,157 @@
+import { ConfigurationError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { browserEndpointSchema, browserOriginSchema, } from "../domain/browserObservation.js";
+import { parseAbsoluteRoots, parseBrowserArray, parseElectronFileRoots, } from "./parsers.js";
+import { browserNetworkScope, permissionScope } from "./permissions.js";
+/** Parse every passive observation capability into closed policy variants. */
+export const parsePassiveObservationPolicies = (env) => {
+    const browser = parseBrowserObservationPolicy(env);
+    if (!browser.ok)
+        return browser;
+    const electron = parseElectronObservationPolicy(env);
+    if (!electron.ok)
+        return electron;
+    const v8Inspector = parseV8InspectorObservationPolicy(env);
+    if (!v8Inspector.ok)
+        return v8Inspector;
+    return ok({
+        browser: browser.value,
+        electron: electron.value,
+        v8Inspector: v8Inspector.value,
+    });
+};
+/** Add permission ceilings for each enabled passive observation policy. */
+export const appendPassiveObservationCeilings = (ceilings, policies) => {
+    appendBrowserCeiling(ceilings, policies.browser);
+    appendElectronCeiling(ceilings, policies.electron);
+    appendV8InspectorCeiling(ceilings, policies.v8Inspector);
+};
+/** Project the legal file and origin scopes from an enabled V8 policy. */
+export const v8InspectorLocationScopes = (locations) => {
+    switch (locations.scope) {
+        case "files":
+            return { fileRoots: locations.fileRoots, allowedOrigins: [] };
+        case "origins":
+            return { fileRoots: [], allowedOrigins: locations.allowedOrigins };
+        case "files-and-origins":
+            return locations;
+    }
+};
+const parseBrowserObservationPolicy = (env) => {
+    const endpoints = parseBrowserArray(env.REA_BROWSER_CDP_ENDPOINTS_JSON, "REA_BROWSER_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
+    if (!endpoints.ok)
+        return endpoints;
+    const origins = parseBrowserArray(env.REA_BROWSER_ALLOWED_ORIGINS_JSON, "REA_BROWSER_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
+    if (!origins.ok)
+        return origins;
+    if (env.REA_BROWSER_OBSERVE_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const parsedEndpoints = requireFirst(endpoints.value, "REA_BROWSER_CDP_ENDPOINTS_JSON must encode at least one loopback endpoint when browser observation is enabled");
+    if (!parsedEndpoints.ok)
+        return parsedEndpoints;
+    const parsedOrigins = requireFirst(origins.value, "REA_BROWSER_ALLOWED_ORIGINS_JSON must encode at least one exact origin when browser observation is enabled");
+    if (!parsedOrigins.ok)
+        return parsedOrigins;
+    return ok({
+        status: "enabled",
+        cdpEndpoints: parsedEndpoints.value,
+        allowedOrigins: parsedOrigins.value,
+    });
+};
+const parseElectronObservationPolicy = (env) => {
+    const endpoints = parseBrowserArray(env.REA_ELECTRON_CDP_ENDPOINTS_JSON, "REA_ELECTRON_CDP_ENDPOINTS_JSON", browserEndpointSchema, 16);
+    if (!endpoints.ok)
+        return endpoints;
+    const roots = parseElectronFileRoots(env.REA_ELECTRON_FILE_ROOTS_JSON);
+    if (!roots.ok)
+        return roots;
+    if (env.REA_ELECTRON_OBSERVE_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const parsedEndpoints = requireFirst(endpoints.value, "REA_ELECTRON_CDP_ENDPOINTS_JSON must encode at least one loopback endpoint when Electron observation is enabled");
+    if (!parsedEndpoints.ok)
+        return parsedEndpoints;
+    const parsedRoots = requireFirst(roots.value, "REA_ELECTRON_FILE_ROOTS_JSON must encode at least one absolute root when Electron observation is enabled");
+    if (!parsedRoots.ok)
+        return parsedRoots;
+    return ok({
+        status: "enabled",
+        cdpEndpoints: parsedEndpoints.value,
+        fileRoots: parsedRoots.value,
+    });
+};
+const parseV8InspectorObservationPolicy = (env) => {
+    const endpoints = parseBrowserArray(env.REA_V8_INSPECTOR_ENDPOINTS_JSON, "REA_V8_INSPECTOR_ENDPOINTS_JSON", browserEndpointSchema, 16);
+    if (!endpoints.ok)
+        return endpoints;
+    const roots = parseAbsoluteRoots(env.REA_V8_INSPECTOR_FILE_ROOTS_JSON, "REA_V8_INSPECTOR_FILE_ROOTS_JSON");
+    if (!roots.ok)
+        return roots;
+    const origins = parseBrowserArray(env.REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON, "REA_V8_INSPECTOR_ALLOWED_ORIGINS_JSON", browserOriginSchema, 32);
+    if (!origins.ok)
+        return origins;
+    if (env.REA_V8_INSPECTOR_OBSERVE_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const parsedEndpoints = requireFirst(endpoints.value, "REA_V8_INSPECTOR_ENDPOINTS_JSON must encode at least one loopback endpoint when V8 Inspector observation is enabled");
+    if (!parsedEndpoints.ok)
+        return parsedEndpoints;
+    const locations = parseV8Locations(roots.value, origins.value);
+    if (!locations.ok)
+        return locations;
+    return ok({
+        status: "enabled",
+        endpoints: parsedEndpoints.value,
+        locations: locations.value,
+    });
+};
+const parseV8Locations = (roots, origins) => {
+    const [firstRoot, ...remainingRoots] = roots;
+    const [firstOrigin, ...remainingOrigins] = origins;
+    if (firstRoot !== undefined && firstOrigin !== undefined)
+        return ok({
+            scope: "files-and-origins",
+            fileRoots: [firstRoot, ...remainingRoots],
+            allowedOrigins: [firstOrigin, ...remainingOrigins],
+        });
+    if (firstRoot !== undefined)
+        return ok({
+            scope: "files",
+            fileRoots: [firstRoot, ...remainingRoots],
+        });
+    if (firstOrigin !== undefined)
+        return ok({
+            scope: "origins",
+            allowedOrigins: [firstOrigin, ...remainingOrigins],
+        });
+    return err(new ConfigurationError("V8 Inspector observation requires at least one file root or exact origin when enabled"));
+};
+const requireFirst = (values, message) => {
+    const [first, ...remaining] = values;
+    return first === undefined
+        ? err(new ConfigurationError(message))
+        : ok([first, ...remaining]);
+};
+const appendBrowserCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    ceilings.push(permissionScope("browser_observe", [], {
+        origins: [...policy.cdpEndpoints, ...policy.allowedOrigins],
+        network: browserNetworkScope(policy.allowedOrigins),
+    }));
+};
+const appendElectronCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    ceilings.push(permissionScope("electron_observe", policy.fileRoots, {
+        origins: policy.cdpEndpoints,
+        network: "loopback",
+    }));
+};
+const appendV8InspectorCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    const scopes = v8InspectorLocationScopes(policy.locations);
+    ceilings.push(permissionScope("v8_inspector_observe", scopes.fileRoots, {
+        origins: [...policy.endpoints, ...scopes.allowedOrigins],
+        network: "loopback",
+    }));
+};

package/dist/config/processCapture.js

@@ -0,0 +1,47 @@
+import { ConfigurationError } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { parseAbsoluteRoots, parseStringArray } from "./parsers.js";
+import { permissionScope } from "./permissions.js";
+/** Parse process capture into disabled or fully authorized state. */
+export const parseProcessExecutionPolicy = (env) => {
+    const executableRoots = parseAbsoluteRoots(env.REA_PROCESS_EXECUTABLE_ROOTS_JSON, "REA_PROCESS_EXECUTABLE_ROOTS_JSON");
+    if (!executableRoots.ok)
+        return executableRoots;
+    const workingRoots = parseAbsoluteRoots(env.REA_PROCESS_WORKING_ROOTS_JSON, "REA_PROCESS_WORKING_ROOTS_JSON");
+    if (!workingRoots.ok)
+        return workingRoots;
+    const allowedEnvironment = parseStringArray(env.REA_PROCESS_ALLOWED_ENV_JSON, "REA_PROCESS_ALLOWED_ENV_JSON");
+    if (!allowedEnvironment.ok)
+        return allowedEnvironment;
+    if (env.REA_PROCESS_CAPTURE_ENABLED !== "true")
+        return ok({ status: "disabled" });
+    const parsedExecutables = requireRoots(executableRoots.value, "REA_PROCESS_EXECUTABLE_ROOTS_JSON must encode at least one absolute root when process capture is enabled");
+    if (!parsedExecutables.ok)
+        return parsedExecutables;
+    const parsedWorking = requireRoots(workingRoots.value, "REA_PROCESS_WORKING_ROOTS_JSON must encode at least one absolute root when process capture is enabled");
+    if (!parsedWorking.ok)
+        return parsedWorking;
+    return ok({
+        status: "enabled",
+        executableRoots: parsedExecutables.value,
+        workingRoots: parsedWorking.value,
+        allowedEnvironment: allowedEnvironment.value,
+        networkAccess: env.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true" ? "external" : "none",
+    });
+};
+/** Add the exact process-capture ceiling when capture is enabled. */
+export const appendProcessCaptureCeiling = (ceilings, policy) => {
+    if (policy.status === "disabled")
+        return;
+    ceilings.push(permissionScope("process_capture", policy.workingRoots, {
+        executables: policy.executableRoots,
+        environment_names: policy.allowedEnvironment,
+        network: policy.networkAccess,
+    }));
+};
+const requireRoots = (roots, message) => {
+    const [first, ...remaining] = roots;
+    return first === undefined
+        ? err(new ConfigurationError(message))
+        : ok([first, ...remaining]);
+};

package/dist/contracts/applicationToolContracts.js

@@ -69,7 +69,6 @@ const NODE_PREPARATION_EXAMPLE = jsonObjectSchema.parse({
             entry_export: "selected",
         },
         cases: [{ case_id: "empty", arguments: [""] }],
-        approved: false,
     },
 });
 const COVERAGE_WORKSPACE_EXAMPLE = jsonObjectSchema.parse({
@@ -226,7 +225,6 @@ export const APPLICATION_TOOL_CONTRACTS = [
                         result_depth: 16,
                         result_nodes: 10000,
                     },
-                    approved: false,
                 },
             },
         ],
@@ -347,10 +345,9 @@ export const APPLICATION_TOOL_CONTRACTS = [
         ],
     },
 ];
-/** Resolve one named application contract without relying on array position. */
-export const applicationToolContract = (name) => {
+export function applicationToolContract(name) {
     const contract = APPLICATION_TOOL_CONTRACTS.find(({ name: candidate }) => candidate === name);
     if (contract === undefined)
         throw new Error(`Missing application tool contract: ${name}`);
     return contract;
-};
+}