rea-agents 3.2.1 → 4.0.1

package/dist/cliSetup.js

@@ -9,37 +9,36 @@ const promptStreams = {
     output: process.stderr,
     withGuide: true,
 };
-const agentIntegrationCapabilityId = "agent_integration";
-/** Run the inline setup picker, exact preflight, and explicit consent. */
-export const confirmInteractiveSetup = async (actions, accessible) => {
-    intro("REA setup", promptStreams);
-    renderValueIntroduction();
-    renderDetectedSummary(actions);
-    renderKeyboardHelp(accessible);
-    const selectedActionIds = await selectSetupActions(actions, accessible);
-    if (selectedActionIds === undefined)
-        return cancelledDecision();
-    if (selectedActionIds.length === 0) {
-        cancel("Nothing selected. No changes were made.", promptStreams);
-        return { approved: false, selectedActionIds };
+/** Select agent targets, then review the resolved plan before consent. */
+export const confirmInteractiveSetup = async (actions, accessible, context) => {
+    if (context?.stage === "select" || context === undefined) {
+        intro("REA setup", promptStreams);
+        writeLine("│  Understand local apps and binaries from your terminal or agent.");
+        renderDetectedSummary(context?.clientStates ?? []);
+        renderKeyboardHelp(accessible);
+    }
+    if (context?.stage === "select") {
+        const selected = await selectSetupActions(actions, accessible, context);
+        return selected === undefined
+            ? cancelledDecision()
+            : { approved: false, selectedActionIds: selected };
     }
-    const selected = new Set(selectedActionIds);
-    const selectedActions = actions.filter(({ id }) => selected.has(id));
-    renderPreflight(selectedActions);
+    if (actions.length === 0)
+        return { approved: true, selectedActionIds: [] };
+    renderPreflight(actions);
     const approved = await confirm({
         ...promptStreams,
-        message: selectedActions.length === 1
+        message: actions.length === 1
             ? "Apply this change?"
-            : `Apply these ${String(selectedActions.length)} changes?`,
+            : `Apply these ${String(actions.length)} changes?`,
         initialValue: true,
         active: "Yes, apply",
         inactive: "No, cancel",
+        vertical: accessible,
     });
-    if (isCancel(approved) || !approved) {
-        cancel("Setup cancelled. No changes were made.", promptStreams);
-        return { approved: false, selectedActionIds };
-    }
-    return { approved: true, selectedActionIds };
+    if (isCancel(approved) || !approved)
+        return cancelledDecision();
+    return { approved: true, selectedActionIds: actions.map(({ id }) => id) };
 };
 /** Render stable, append-only progress for real setup operations. */
 export const renderSetupProgress = (event) => {
@@ -66,156 +65,101 @@ export const renderInteractiveSetupResult = (result) => {
             : `Restart ${changedClients.join(", ")} to load REA.`, promptStreams);
         return;
     }
-    if (result.status === "planned")
+    if (result.status === "planned" || result.status === "cancelled")
         return;
     writeLine(`!  ${result.remediation ?? "Setup needs attention."}`);
-    outro("Run `rea doctor` for the remaining checks.", promptStreams);
-};
-const selectSetupActions = async (actions, accessible) => {
-    const clientActions = actions.filter(({ kind }) => kind === "configure_client");
-    const componentActions = actions.filter(({ kind }) => kind !== "configure_client");
-    const capabilities = setupCapabilities(clientActions, componentActions);
-    const preselectedCapabilityIds = defaultCapabilityIds(capabilities);
-    const selectedCapabilities = accessible
-        ? await selectCapabilitiesAccessibly(capabilities, preselectedCapabilityIds)
-        : await selectCapabilities(capabilities, preselectedCapabilityIds);
-    if (selectedCapabilities === undefined)
-        return undefined;
-    const selectedCapabilityIds = new Set(selectedCapabilities);
-    const bundledSkillAction = componentActions.find(({ kind }) => kind === "install_skill");
-    const selectedActionIds = componentActions
-        .filter(({ id }) => id !== bundledSkillAction?.id && selectedCapabilityIds.has(id))
-        .map(({ id }) => id);
-    if (!selectedCapabilityIds.has(agentIntegrationCapabilityId))
-        return selectedActionIds;
-    const bundledSkillId = bundledSkillAction === undefined ? undefined : bundledSkillAction.id;
-    if (clientActions.length === 0)
-        return [
-            ...(bundledSkillId === undefined ? [] : [bundledSkillId]),
-            ...selectedActionIds,
-        ];
-    const preselectedClientIds = clientActions.map(({ id }) => id);
-    const selectedClients = accessible
-        ? await selectClientsAccessibly(clientActions, preselectedClientIds)
-        : await selectClients(clientActions, preselectedClientIds);
-    if (selectedClients === undefined)
+    outro(`Run \`${cliInvocation()} doctor\` for the remaining checks.`, promptStreams);
+};
+const selectSetupActions = async (actions, accessible, context) => {
+    const clientStates = context.clientStates.filter(({ client }) => client.format !== "unsupported");
+    const initial = new Set(context.selectedClientIds);
+    const selectedClientIds = accessible
+        ? await selectClientsAccessibly(clientStates, initial)
+        : await selectClients(clientStates, initial);
+    if (selectedClientIds === undefined)
         return undefined;
-    return [
-        ...selectedClients,
-        ...(bundledSkillId === undefined ? [] : [bundledSkillId]),
-        ...selectedActionIds,
-    ];
-};
-const defaultCapabilityIds = (capabilities) => {
-    const hasAgentIntegration = capabilities.some(({ id }) => id === agentIntegrationCapabilityId);
-    if (!hasAgentIntegration)
-        return [];
-    return [agentIntegrationCapabilityId];
-};
-const setupCapabilities = (clientActions, componentActions) => [
-    ...(clientActions.length === 0 &&
-        !componentActions.some(({ kind }) => kind === "install_skill")
-        ? []
-        : [
-            {
-                id: agentIntegrationCapabilityId,
-                label: "Agent integration (MCP + guided workflow)",
-                hint: clientActions.length === 0
-                    ? "MCP registrations are aligned; installs the matching bundled skill"
-                    : `${String(clientActions.length)} detected ${clientActions.length === 1 ? "agent" : "agents"}; installs the bundled skill when needed`,
-            },
-        ]),
-    ...componentActions
-        .filter(({ kind }) => kind !== "install_skill")
-        .map((action) => ({
-        id: action.id,
-        label: `${action.label} (${actionModality(action)})`,
-        hint: `${action.operation} · ${action.target}`,
-    })),
-];
-const selectCapabilities = async (capabilities, initialValues) => {
-    const selection = await multiselect({
-        ...promptStreams,
-        message: "What should REA set up?",
-        options: capabilities.map((capability) => ({
-            value: capability.id,
-            label: capability.label,
-            hint: capability.hint,
-        })),
-        initialValues: [...initialValues],
-        required: false,
-        maxItems: Math.max(3, Math.min(capabilities.length, (process.stderr.rows ?? 24) - 8)),
-        showInstructions: true,
-    });
-    return isCancel(selection) ? undefined : selection;
-};
-const selectCapabilitiesAccessibly = async (capabilities, preselectedIds) => {
-    const preselected = new Set(preselectedIds);
-    const selected = [];
-    for (const capability of capabilities) {
+    const selectedActionIds = selectedClientIds.map((id) => `configure_client:${id}`);
+    const skill = actions.find(({ kind }) => kind === "install_skill");
+    if (skill !== undefined) {
+        if (selectedClientIds.length > 0)
+            selectedActionIds.push(skill.id);
+        else {
+            const included = await confirm({
+                ...promptStreams,
+                message: "Install the guided REA skill for CLI use?",
+                initialValue: false,
+                vertical: accessible,
+            });
+            if (isCancel(included))
+                return undefined;
+            if (included)
+                selectedActionIds.push(skill.id);
+        }
+    }
+    const hopper = actions.find(({ kind }) => kind === "install_hopper");
+    if (hopper !== undefined) {
         const included = await confirm({
             ...promptStreams,
-            message: `Set up ${capability.label}? ${capability.hint}`,
-            initialValue: preselected.has(capability.id),
-            vertical: true,
+            message: "Install Hopper for deep binary analysis?",
+            initialValue: false,
+            vertical: accessible,
         });
         if (isCancel(included))
             return undefined;
         if (included)
-            selected.push(capability.id);
+            selectedActionIds.push(hopper.id);
     }
-    return selected;
-};
-const selectClients = async (actions, initialValues) => {
+    return selectedActionIds;
+};
+const clientHint = (state) => state.configured
+    ? "REA already configured · selected from existing configuration"
+    : state.status === "invalid"
+        ? "Existing configuration needs repair before setup"
+        : state.detected
+            ? "Detected · choose to configure"
+            : "Not detected · configuration is still available";
+const selectClients = async (states, initial) => {
+    if (states.length === 0)
+        return [];
     const selection = await multiselect({
         ...promptStreams,
         message: "Which agents should use REA?",
-        options: actions.map((action) => ({
-            value: action.id,
-            label: `${action.label} (detected)`,
-            hint: `Configure the REA MCP server for ${action.label}`,
+        options: states.map((state) => ({
+            value: state.client.name,
+            label: clientDisplayNames.get(state.client.name) ?? state.client.name,
+            hint: clientHint(state),
         })),
-        initialValues: [...initialValues],
+        initialValues: states
+            .filter(({ client }) => initial.has(client.name))
+            .map(({ client }) => client.name),
         required: false,
-        maxItems: Math.max(3, Math.min(actions.length, (process.stderr.rows ?? 24) - 8)),
+        maxItems: Math.max(3, Math.min(states.length, (process.stderr.rows ?? 24) - 8)),
         showInstructions: true,
     });
     return isCancel(selection) ? undefined : selection;
 };
-const selectClientsAccessibly = async (actions, initialValues) => {
-    const preselected = new Set(initialValues);
+const selectClientsAccessibly = async (states, initial) => {
     const selected = [];
-    for (const action of actions) {
+    for (const state of states) {
         const included = await confirm({
             ...promptStreams,
-            message: `Configure ${action.label}? ${action.target}`,
-            initialValue: preselected.has(action.id),
+            message: `Configure ${clientDisplayNames.get(state.client.name) ?? state.client.name}? ${clientHint(state)}`,
+            initialValue: initial.has(state.client.name),
             vertical: true,
         });
         if (isCancel(included))
             return undefined;
         if (included)
-            selected.push(action.id);
+            selected.push(state.client.name);
     }
     return selected;
 };
-const renderValueIntroduction = () => {
-    writeLine("│  Understand local apps and binaries from your coding agent.");
+const renderDetectedSummary = (states) => {
+    const detected = states.filter(({ detected }) => detected);
     writeLine("│");
-    writeLine("│  • Trace how a feature works with local evidence.");
-    writeLine("│  • Use the same analysis capabilities from REA's CLI and supported agents.");
-    writeLine("│  • Keep analyzed targets on this machine instead of uploading them to a hosted service.");
-};
-const renderDetectedSummary = (actions) => {
-    const clients = actions.filter(({ kind }) => kind === "configure_client");
-    writeLine("│");
-    if (clients.length === 0) {
-        writeLine("◆  No agent integrations need configuration");
-    }
-    else {
-        writeLine(`◆  Found ${String(clients.length)} supported ${clients.length === 1 ? "agent" : "agents"}`);
-        writeLine(`│  ${humanList(clients.map(({ label }) => label))}`);
-    }
+    writeLine(detected.length === 0
+        ? "◆  No agents detected. Choose any supported agent below."
+        : `◆  Detected: ${humanList(detected.map(({ client }) => clientDisplayNames.get(client.name) ?? client.name))}`);
 };
 const renderKeyboardHelp = (accessible) => {
     writeLine("│");
@@ -223,6 +167,7 @@ const renderKeyboardHelp = (accessible) => {
         ? "│  Keys: Enter answer · Ctrl-C cancel"
         : "│  Keys: ↑/↓ navigate · Space toggle · Enter confirm · Ctrl-C cancel");
 };
+const cliInvocation = () => process.env.npm_command === "exec" ? "npx rea-agents" : "rea";
 const renderReadyCapabilities = (result, readyClients) => {
     writeLine("◆  What you can do now");
     const providers = readyProviders(result);
@@ -232,8 +177,7 @@ const renderReadyCapabilities = (result, readyClients) => {
         writeLine(`│  Agent access: ${humanList(readyClients)}`);
     if (result.doctor.identity?.skill.state === "aligned")
         writeLine("│  Guided reverse-engineering workflows: installed");
-    if (providers.length > 0)
-        writeLine("│  CLI: rea analyze /path/to/app");
+    writeLine(`│  CLI: ${cliInvocation()} ${providers.length > 0 ? "analyze /path/to/app" : "capabilities"}`);
     const firstClient = readyClients[0];
     if (firstClient !== undefined)
         writeLine(`│  Try in ${firstClient}: "Explain how a feature works in /path/to/app and show the evidence."`);
@@ -244,23 +188,8 @@ const readyAgentClients = (result, changedClients) => {
         .map(({ client }) => clientDisplayNames.get(client) ?? client);
     return [...new Set([...alignedClients, ...changedClients])];
 };
-const readyProviders = (result) => {
-    const providers = [
-        ...(result.doctor.hopperPath === undefined ? [] : ["Hopper"]),
-        ...(result.doctor.providerInspections ?? [])
-            .filter(({ available }) => available)
-            .map(({ id }) => displayProviderId(id)),
-    ];
-    return [...new Set(providers)];
-};
+const readyProviders = (result) => result.doctor.availableProviders.map(displayProviderId);
 const displayProviderId = (id) => id.length === 0 ? id : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
-const actionModality = (action) => {
-    if (action.kind === "configure_client")
-        return "MCP";
-    if (action.kind === "install_hopper")
-        return "provider";
-    return "skill";
-};
 const humanList = (values) => {
     if (values.length < 2)
         return values[0] ?? "";
@@ -295,6 +224,7 @@ const cancelledDecision = () => {
     return {
         approved: false,
         selectedActionIds: [],
+        cancelled: true,
     };
 };
 const writeLine = (line) => {

package/dist/config/environment.js

@@ -3,8 +3,7 @@ import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
-const environmentSchema = z
-    .object({
+const environmentSchema = z.object({
     REA_ANALYSIS_PROVIDER: analysisProviderSelectorSchema.default("auto"),
     GHIDRA_INSTALL_DIR: z
         .string()
@@ -23,87 +22,12 @@ const environmentSchema = z
         .optional(),
     HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
     HOPPER_TARGET_PATH: z.string().min(1).optional(),
-    HOPPER_TARGET_KIND: z
-        .enum(["executable", "database"])
-        .default("executable"),
+    HOPPER_TARGET_KIND: z.enum(["executable", "database"]).default("executable"),
     HOPPER_LOADER_ARGS_JSON: z.string().optional(),
     REA_LOG_LEVEL: z
         .enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"])
         .default("info"),
-    REA_PROCESS_CAPTURE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_PROCESS_CAPTURE_AUTO_GRANT: z.enum(["true", "false"]).default("true"),
-    REA_ARTIFACT_NATIVE_MOUNT_ENABLED: z
-        .enum(["true", "false"])
-        .default("false"),
-    REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED: z
-        .enum(["true", "false"])
-        .default("false"),
-    REA_PROCESS_ALLOW_EXTERNAL_NETWORK: z
-        .enum(["true", "false"])
-        .default("false"),
-    REA_PROCESS_EXECUTABLE_ROOTS_JSON: z.string().default("[]"),
-    REA_PROCESS_WORKING_ROOTS_JSON: z.string().default("[]"),
-    REA_PROCESS_ALLOWED_ENV_JSON: z.string().default("[]"),
     REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
-    REA_BROWSER_OBSERVE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_BROWSER_CDP_ENDPOINTS_JSON: z.string().default("[]"),
-    REA_BROWSER_ALLOWED_ORIGINS_JSON: z.string().default("[]"),
-    REA_BROWSER_SCENARIO_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_BROWSER_SCENARIO_AUTO_GRANT: z.enum(["true", "false"]).default("false"),
-    REA_BROWSER_SCENARIO_EXECUTABLE_ROOTS_JSON: z.string().default("[]"),
-    REA_BROWSER_SCENARIO_CDP_ENDPOINTS_JSON: z.string().default("[]"),
-    REA_BROWSER_SCENARIO_ALLOWED_ORIGINS_JSON: z.string().default("[]"),
-    REA_BROWSER_SCENARIO_ALLOWED_ENV_JSON: z.string().default("[]"),
-    REA_ELECTRON_OBSERVE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_ELECTRON_AUTOMATE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_ELECTRON_AUTOMATE_AUTO_GRANT: z
-        .enum(["true", "false"])
-        .default("false"),
-    REA_ELECTRON_AUTOMATE_EXECUTABLE_ROOTS_JSON: z.string().default("[]"),
-    REA_ELECTRON_AUTOMATE_APPLICATION_ROOTS_JSON: z.string().default("[]"),
-    REA_V8_INSPECTOR_OBSERVE_ENABLED: z
-        .enum(["true", "false"])
-        .default("false"),
-    REA_JAVASCRIPT_REPLAY_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_JAVASCRIPT_REPLAY_ROOTS_JSON: z.string().default("[]"),
-    REA_JAVASCRIPT_REPLAY_NODE_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_JAVASCRIPT_REPLAY_NODE_PATH must be absolute")
-        .default(process.execPath),
-    REA_JAVASCRIPT_REPLAY_BWRAP_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_JAVASCRIPT_REPLAY_BWRAP_PATH must be absolute")
-        .default("/usr/bin/bwrap"),
-    REA_JAVASCRIPT_REPLAY_SYSTEMD_RUN_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_JAVASCRIPT_REPLAY_SYSTEMD_RUN_PATH must be absolute")
-        .default("/usr/bin/systemd-run"),
-    REA_JAVASCRIPT_REPLAY_SYSTEMCTL_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_JAVASCRIPT_REPLAY_SYSTEMCTL_PATH must be absolute")
-        .default("/usr/bin/systemctl"),
-    REA_JAVASCRIPT_REPLAY_SHELL_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_JAVASCRIPT_REPLAY_SHELL_PATH must be absolute")
-        .default("/usr/bin/bash"),
-    REA_MANAGED_RUNTIME_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_MANAGED_RUNTIME_ROOTS_JSON: z.string().default("[]"),
-    REA_MANAGED_RUNTIME_EXECUTABLE_PATH: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "REA_MANAGED_RUNTIME_EXECUTABLE_PATH must be absolute")
-        .default("/usr/bin/dotnet"),
-    REA_PERMISSION_PROJECT_ROOT: z.string().min(1).optional(),
-    REA_PERMISSION_PROJECT_STORE: z.string().min(1).optional(),
-})
-    .refine((value) => (value.REA_PERMISSION_PROJECT_ROOT === undefined) ===
-    (value.REA_PERMISSION_PROJECT_STORE === undefined), {
-    message: "REA_PERMISSION_PROJECT_ROOT and REA_PERMISSION_PROJECT_STORE must be configured together",
 });
 export const parseEnvironment = (environment) => {
     const parsed = environmentSchema.safeParse(environment);

package/dist/config/parseConfig.js

@@ -1,123 +1,32 @@
 import { ConfigurationError } from "../domain/errors.js";
 import { ok } from "../domain/result.js";
 import { parseEnvironment } from "./environment.js";
-import { parseStringArray, parseAbsoluteRoots, parseLoaderArgs, } from "./parsers.js";
-import { 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";
+import { parseStringArray, parseLoaderArgs } from "./parsers.js";
 const defaultHopperLauncherPath = () => process.platform === "linux"
     ? "/opt/hopper/bin/Hopper"
-    : DEFAULT_HOPPER_LAUNCHER_PATH;
-const parseAllArrays = (env) => {
+    : "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+/** Parse provider configuration and runtime prerequisites at the composition root. */
+export const parseConfig = (environment) => {
+    const parsed = parseEnvironment(environment);
+    if (!parsed.ok)
+        return parsed;
+    const env = parsed.value;
     const loaderArgs = parseLoaderArgs(env.HOPPER_LOADER_ARGS_JSON);
     if (!loaderArgs.ok)
         return loaderArgs;
     const secretPatterns = parseStringArray(env.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
     if (!secretPatterns.ok)
         return secretPatterns;
-    const managedRuntimeRoots = parseAbsoluteRoots(env.REA_MANAGED_RUNTIME_ROOTS_JSON, "REA_MANAGED_RUNTIME_ROOTS_JSON");
-    if (!managedRuntimeRoots.ok)
-        return managedRuntimeRoots;
     return ok({
-        loaderArgs: loaderArgs.value,
-        secretPatterns: secretPatterns.value,
-        managedRuntimeRoots: managedRuntimeRoots.value,
+        analysisProvider: env.REA_ANALYSIS_PROVIDER,
+        ghidraInstallDir: env.GHIDRA_INSTALL_DIR,
+        ghidraJavaHome: env.JAVA_HOME,
+        ilspyCmdPath: env.REA_ILSPY_CMD_PATH,
+        hopperLauncherPath: env.HOPPER_LAUNCHER_PATH ?? defaultHopperLauncherPath(),
+        hopperTargetPath: env.HOPPER_TARGET_PATH,
+        hopperTargetKind: env.HOPPER_TARGET_KIND,
+        hopperLoaderArgs: loaderArgs.value,
+        logLevel: env.REA_LOG_LEVEL,
+        referenceSourcePolicy: { secretPatterns: secretPatterns.value },
     });
 };
-const appendNativeMountCeiling = (ceilings, env) => {
-    if (env.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true")
-        ceilings.push(permissionScope("native_mount", [], { mount: true }));
-};
-const buildPermissionCeilings = (env, arrays, policies) => {
-    const ceilings = [
-        permissionScope("artifact_extract", ["/"]),
-    ];
-    appendProcessCaptureCeiling(ceilings, policies.processCapture);
-    appendPassiveObservationCeilings(ceilings, policies.passiveObservation);
-    appendBrowserScenarioCeiling(ceilings, policies.browserScenario);
-    appendElectronAutomationCeiling(ceilings, policies.electronAutomation);
-    appendNativeMountCeiling(ceilings, env);
-    appendJavaScriptReplayCeiling(ceilings, policies.javascriptReplay);
-    appendManagedRuntimeCeiling(ceilings, policies.managedRuntime);
-    return ceilings;
-};
-const buildAppConfig = (env, arrays, permissionCeilings, policies) => ({
-    analysisProvider: env.REA_ANALYSIS_PROVIDER,
-    ghidraInstallDir: env.GHIDRA_INSTALL_DIR,
-    ghidraJavaHome: env.JAVA_HOME,
-    ilspyCmdPath: env.REA_ILSPY_CMD_PATH,
-    hopperLauncherPath: env.HOPPER_LAUNCHER_PATH ?? defaultHopperLauncherPath(),
-    hopperTargetPath: env.HOPPER_TARGET_PATH,
-    hopperTargetKind: env.HOPPER_TARGET_KIND,
-    hopperLoaderArgs: arrays.loaderArgs,
-    logLevel: env.REA_LOG_LEVEL,
-    processExecutionPolicy: policies.processCapture,
-    artifactNativeMountEnabled: env.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true",
-    artifactIntegrityContinueEnabled: env.REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED === "true",
-    referenceSourcePolicy: {
-        secretPatterns: arrays.secretPatterns,
-    },
-    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") &&
-        (capability !== "electron_automate" ||
-            env.REA_ELECTRON_AUTOMATE_AUTO_GRANT === "true"))),
-    permissionProjectRoot: env.REA_PERMISSION_PROJECT_ROOT,
-    permissionProjectStore: env.REA_PERMISSION_PROJECT_STORE,
-});
-/**
- * Parse provider and authority configuration once at the composition root.
- * Explicit loader arguments override REA's header-derived defaults for a
- * supported target, allowing callers to refine Hopper's loader behavior without
- * bypassing REA's path and executable-header checks.
- */
-export const parseConfig = (environment) => {
-    const envResult = parseEnvironment(environment);
-    if (!envResult.ok)
-        return envResult;
-    const arraysResult = parseAllArrays(envResult.value);
-    if (!arraysResult.ok)
-        return arraysResult;
-    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,5 +1,4 @@
 import { z } from "zod";
-import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 export const parseStringArray = (encoded, name) => {
@@ -15,28 +14,6 @@ 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) => {
-    try {
-        const parsed = z.array(itemSchema).safeParse(JSON.parse(encoded));
-        return parsed.success
-            ? ok([...new Set(parsed.data)].sort())
-            : err(new ConfigurationError(`${name} must encode valid browser scopes`, {
-                cause: parsed.error,
-            }));
-    }
-    catch (cause) {
-        return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
-    }
-};
 export const parseLoaderArgs = (encoded) => {
     if (encoded === undefined)
         return ok([]);