rea-agents 2.2.0 → 2.4.0

package/dist/application/ProcessReactiveHarness.js

@@ -0,0 +1,85 @@
+import { ProcessCaptureError } from "./ProcessCaptureError.js";
+import { ProcessReactiveCoordinator } from "./ProcessReactiveCoordinator.js";
+import { executeProcessReactiveEffects, unsupportedProcessReactiveFeatures, } from "./ProcessReactiveEffects.js";
+import { subscribeProcessReactiveObservations } from "./ProcessReactiveObservations.js";
+import { normalizeProcessSamples, normalizeProcessShimEvent, redactProtocolEvents, } from "./ProcessNormalization.js";
+const controlKind = (input) => input.kind === "observation" ? undefined : input.kind;
+/** Reject reactive declarations the current process adapter cannot execute. */
+export const assertSupportedReactiveScenario = (scenario) => {
+    if (scenario.reactive === null)
+        return;
+    const unsupported = unsupportedProcessReactiveFeatures(scenario.reactive);
+    if (unsupported.length === 0)
+        return;
+    throw new ProcessCaptureError(`reactive scenario requests unsupported features: ${unsupported.join(", ")}`);
+};
+/**
+ * Attach the serialized reactive runtime once the target PID is available.
+ *
+ * Subscription replays journal entries admitted during launcher startup before
+ * observing new records, so PID-dependent normalization cannot drop them.
+ */
+export const startProcessReactiveHarness = (options) => {
+    if (options.scenario.reactive === null)
+        return undefined;
+    const controls = [];
+    const coordinator = new ProcessReactiveCoordinator({
+        scenario: options.scenario.reactive,
+        executor: {
+            execute: (actions, signal) => executeProcessReactiveEffects({
+                terminal: options.terminal,
+                renderer: options.renderer,
+                checkpoints: options.checkpoints,
+                interactions: options.capture.interactions,
+                journal: options.capture.journal,
+                startedAtMs: options.started,
+                now: Date.now,
+            }, actions, signal),
+        },
+        onDecision: (decision, input) => {
+            const kind = controlKind(input);
+            if (kind === undefined || decision.kind !== "finished")
+                return;
+            controls.push({
+                sequence: controls.length,
+                kind,
+                after_capture_order: decision.snapshot.observations.at(-1)?.capture_order ?? -1,
+            });
+        },
+    });
+    return {
+        coordinator,
+        controls,
+        unsubscribe: subscribeProcessReactiveObservations({
+            journal: options.capture.journal,
+            frames: options.capture.frames,
+            interactions: options.capture.interactions,
+            checkpointAt: (index) => options.checkpoints.at(index),
+            processSampleAt: (index) => {
+                const rootPid = options.terminal()?.pid;
+                return rootPid === undefined
+                    ? undefined
+                    : normalizeProcessSamples(options.capture.processSamples, options.scenario, rootPid)[index];
+            },
+            protocolEventAt: (index) => redactProtocolEvents(options.capture.protocolEvents().slice(index, index + 1), options.scenario)[0],
+            shimEventAt: (index) => {
+                const event = options.shimReplay.events[index];
+                const rootPid = options.terminal()?.pid;
+                return event === undefined || rootPid === undefined
+                    ? undefined
+                    : normalizeProcessShimEvent(event, options.scenario, options.capture.temporaryRoot, rootPid);
+            },
+            sink: coordinator,
+        }),
+    };
+};
+/** Project internal reducer state into the stable Process Capture shape. */
+export const projectProcessReactiveRun = (harness) => harness === undefined
+    ? null
+    : {
+        status: harness.coordinator.snapshot.status,
+        outcome: harness.coordinator.snapshot.outcome,
+        active_state: harness.coordinator.snapshot.active_state,
+        transitions: harness.coordinator.snapshot.transitions,
+        controls: harness.controls,
+    };

package/dist/application/ProcessReactiveObservations.js

@@ -0,0 +1,105 @@
+import { createProcessObservation, processObservationSubject, } from "../domain/processObservation.js";
+const terminalObservation = (options, entry) => {
+    const value = options.frames[entry.index];
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "terminal_raw",
+            source_sequence: value.sequence,
+            captured_at_ms: value.at_ms,
+            subject_id: null,
+            location: entry,
+            payload: value,
+        });
+};
+const interactionObservation = (options, entry) => {
+    const value = options.interactions[entry.index];
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "interaction",
+            source_sequence: value.sequence,
+            captured_at_ms: value.dispatched_at_ms,
+            subject_id: null,
+            location: entry,
+            payload: value,
+        });
+};
+const filesystemObservation = (options, entry) => {
+    const value = options.checkpointAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "filesystem",
+            source_sequence: entry.index,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject("filesystem", value),
+            location: entry,
+            payload: value,
+        });
+};
+const processObservation = (options, entry) => {
+    const value = options.processSampleAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "process",
+            source_sequence: entry.index,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject("process", value),
+            location: entry,
+            payload: value,
+        });
+};
+const protocolObservation = (options, entry) => {
+    const value = options.protocolEventAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: value.protocol,
+            source_sequence: value.sequence,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject(value.protocol, value),
+            location: entry,
+            payload: value,
+        });
+};
+const shimObservation = (options, entry) => {
+    const normalized = options.shimEventAt(entry.index);
+    if (normalized === undefined)
+        return undefined;
+    return createProcessObservation({
+        source: "shim",
+        source_sequence: normalized.sequence,
+        captured_at_ms: normalized.at_ms,
+        subject_id: processObservationSubject("shim", normalized),
+        location: entry,
+        payload: normalized,
+    });
+};
+const observationFor = (options, entry) => {
+    if (entry.collection === "frames")
+        return terminalObservation(options, entry);
+    if (entry.collection === "interaction_events")
+        return interactionObservation(options, entry);
+    if (entry.collection === "filesystem_checkpoints")
+        return filesystemObservation(options, entry);
+    if (entry.collection === "process_samples")
+        return processObservation(options, entry);
+    if (entry.collection === "protocol_events")
+        return protocolObservation(options, entry);
+    if (entry.collection === "shim_events")
+        return shimObservation(options, entry);
+    return undefined;
+};
+/** Subscribe the reactive coordinator to admitted normalized journal records. */
+export const subscribeProcessReactiveObservations = (options) => {
+    const enqueue = (entry) => {
+        const observation = observationFor(options, entry);
+        if (observation !== undefined)
+            options.sink.enqueue({ kind: "observation", observation });
+    };
+    for (const entry of options.journal.entries)
+        enqueue(entry);
+    return options.journal.subscribe(enqueue);
+};

package/dist/application/ProcessSampling.js

@@ -366,7 +366,9 @@ export const startProcessSampler = (options) => {
                     continue;
                 }
                 lastObservations.set(value.pid, observation);
+                const index = samples.length;
                 samples.push(value);
+                options.recordEvent?.("process_samples", index);
             }
         })
             .catch((cause) => {

package/dist/application/SessionProviderRouter.js

@@ -86,7 +86,7 @@ export class SessionProviderRouter {
             compatibility: {},
             binding: null,
             selection: undefined,
-            createClient: (target) => createLegacyClient(runtime, target, undefined),
+            createClient: (target, context) => createLegacyClient(runtime, target, undefined, context),
         };
     }
     /** Resolve target routes before any provider client is created. */
@@ -122,7 +122,7 @@ export class SessionProviderRouter {
             compatibility: normalized.value.compatibility,
             binding: null,
             selection: undefined,
-            createClient: (openedTarget) => createLegacyClient(runtime, openedTarget, normalized.value.profile ?? undefined),
+            createClient: (openedTarget, context) => createLegacyClient(runtime, openedTarget, normalized.value.profile ?? undefined, context),
         });
     }
     /** Candidate status authoritative for the active or target-free route. */
@@ -156,12 +156,13 @@ const selectableRoute = (auxiliaryProviders, selection) => {
         compatibility: structuredClone(binding?.compatibility ?? {}),
         binding,
         selection,
-        createClient: (target) => provider?.createClient(target, binding?.profile) ?? emptyClient(identity),
+        createClient: (target, context) => provider?.createClient(target, binding?.profile, context) ??
+            emptyClient(identity),
     };
 };
-const createLegacyClient = (runtime, target, profile) => typeof runtime.provider === "function"
-    ? runtime.provider(target, profile)
-    : runtime.provider.createClient(target, profile);
+const createLegacyClient = (runtime, target, profile, context) => typeof runtime.provider === "function"
+    ? runtime.provider(target, profile, context)
+    : runtime.provider.createClient(target, profile, context);
 const emptyClient = (identity) => ({
     execute: (operation) => operation === "health"
         ? Promise.resolve(ok({

package/dist/application/Setup.js

@@ -13,6 +13,8 @@ import { discoverSetupActions } from "./SetupPlan.js";
 import { clientConfigurationAligned, configureJsonClient, configureTomlClient, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
 export { configureJsonClient, configureTomlClient };
 import { setupInstallFailure, } from "./SetupInstallFailure.js";
+import { providerRegistrationEnvironment, registrationPermissionEnvironment, } from "./SetupRegistrationEnvironment.js";
+export { registrationPermissionEnvironment } from "./SetupRegistrationEnvironment.js";
 export { canonicalSkillNeedsInstall, installCanonicalSkill };
 const registrationCommand = () => process.env.npm_command === "exec"
     ? PRODUCT_IDENTITY.mcpCommand.split(" ")
@@ -22,7 +24,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const appliedActions = [];
     let plannedActions = [];
     const clients = {};
-    const fail = (remediation) => setupFailure(remediation, [host, plannedActions, appliedActions, clients]);
+    const fail = (remediation) => setupFailure(remediation, [host, plannedActions, appliedActions, clients], options.readinessScope);
     const unsupported = await hostRemediation(host, options.installHopper);
     if (unsupported !== undefined)
         return fail(unsupported);
@@ -36,6 +38,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         proposeHopper: options.proposeHopper ?? true,
         selectedClientIds: options.clientIds,
         installSkillSelection: options.installSkill,
+        doctorScope: options.readinessScope,
     });
     if (discovery.blocker !== undefined)
         return fail(discovery.blocker);
@@ -61,6 +64,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
             clients,
             detectedClients,
             providerEnvironment,
+            doctorScope: options.readinessScope,
         });
         if ("failure" in install)
             return install.failure;
@@ -82,7 +86,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     if (selection.installSkill &&
         !(await installSkillAction(host, options, appliedActions)))
         return fail("REA analysis skill could not be installed or verified. Check permissions for `~/.agents/skills`, then rerun setup.");
-    const doctor = await host.doctor();
+    const doctor = await host.doctor(options.readinessScope);
     const remediation = finalSetupRemediation(host.platform, appliedActions.includes("installed_hopper"), doctor.healthy, hopperPath);
     return {
         status: remediation === undefined ? "ready" : "needs_human",
@@ -143,7 +147,7 @@ const installHopperAction = async (input) => {
                 plannedActions: input.plannedActions,
                 appliedActions: input.appliedActions,
                 clients: input.clients,
-                doctor: await input.host.doctor(),
+                doctor: await input.host.doctor(input.doctorScope),
                 code: installed.code,
                 remediation: installed.remediation,
             },
@@ -192,12 +196,12 @@ const installSkillAction = async (host, options, appliedActions) => {
     });
     return true;
 };
-const setupFailure = async (remediation, [host, plannedActions, appliedActions, clients]) => ({
+const setupFailure = async (remediation, [host, plannedActions, appliedActions, clients], scope) => ({
     status: "needs_human",
     plannedActions,
     appliedActions,
     clients,
-    doctor: await host.doctor(),
+    doctor: await host.doctor(scope),
     remediation,
 });
 const emitProgress = (options, event) => options.onProgress?.(event);
@@ -250,6 +254,7 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
             const diagnosis = await runDoctor(undefined, doctorHost);
             return {
                 ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
+                ...registrationPermissionEnvironment(process.env),
                 ...(diagnosis.hopperPath === undefined
                     ? {}
                     : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
@@ -273,7 +278,7 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
         inspectClientConfiguration: inspectClientConfiguration,
         skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
         installSkill: () => installCanonicalSkill(homedir()),
-        doctor: () => runDoctor(undefined, doctorHost),
+        doctor: (scope) => runDoctor(undefined, doctorHost, scope),
     };
 };
 /** Detect supported agents from stable per-user installation markers. */
@@ -294,7 +299,3 @@ const exists = async (path) => {
         return false;
     }
 };
-const providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections
-    .filter(({ available }) => available)
-    .flatMap(({ registrationEnvironment }) => Object.entries(registrationEnvironment))
-    .sort(([left], [right]) => left.localeCompare(right)));

package/dist/application/SetupPlan.js

@@ -59,7 +59,7 @@ const setupPlan = (input) => [
 /** Discover and preflight the complete set of selectable setup actions. */
 export const discoverSetupActions = async (input) => {
     const { host, providerEnvironment, command } = input;
-    const initialDoctor = await host.doctor();
+    const initialDoctor = await host.doctor(input.doctorScope);
     const linuxHopperRepairNeeded = initialDoctor.checks.some(({ name, ok, detail }) => !ok &&
         (name === "hopper-demo-runtime" ||
             (name === "hopper-version" && detail === "/opt/hopper/bin/Hopper")));

package/dist/application/SetupRegistrationEnvironment.js

@@ -0,0 +1,12 @@
+/** Select explicit non-secret permission settings safe for managed MCP registrations. */
+export const registrationPermissionEnvironment = (environment) => {
+    const investigationRoots = environment.REA_INVESTIGATION_INPUT_ROOTS_JSON;
+    return investigationRoots === undefined
+        ? {}
+        : { REA_INVESTIGATION_INPUT_ROOTS_JSON: investigationRoots };
+};
+/** Select exact non-secret settings published by available providers. */
+export const providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections
+    .filter(({ available }) => available)
+    .flatMap(({ registrationEnvironment }) => Object.entries(registrationEnvironment))
+    .sort(([left], [right]) => left.localeCompare(right)));

package/dist/application/TerminalRenderer.js

@@ -77,8 +77,9 @@ export class TerminalRenderer {
             return;
         }
         this.#capturedBytes += bytes;
+        const sequence = this.#frames.length;
         this.#frames.push({
-            sequence: this.#frames.length,
+            sequence,
             at_ms: atMs,
             columns: this.#terminal.cols,
             rows: this.#terminal.rows,
@@ -88,5 +89,6 @@ export class TerminalRenderer {
             lines,
             serialized_state: serializedState,
         });
+        this.options.recordEvent?.("rendered_frames", sequence);
     }
 }

package/dist/browser/CdpEndpoint.js

@@ -40,25 +40,58 @@ export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
         targets: targets.map((target) => ({
             id: target.id,
             type: target.type,
-            title: sanitizeTargetTitle(target.title),
+            title: sanitizeTargetTitle(target.title, target.url),
             url: target.url,
             attached: target.attached,
             ...targetWebSocket(endpoint, target, operation),
         })),
     };
 };
-const sanitizeTargetTitle = (value) => {
+const sanitizeTargetTitle = (value, targetUrl) => {
     let url;
     try {
         url = new URL(value);
     }
     catch {
-        return value;
+        return sanitizeTargetUrlAlias(value, targetUrl);
     }
     return url.protocol === "http:" || url.protocol === "https:"
         ? sanitizeBrowserUrl(value).url.slice(0, 16_384)
-        : value;
+        : sanitizeTargetUrlAlias(value, targetUrl);
+};
+const sanitizeTargetUrlAlias = (value, targetUrl) => {
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    }
+    catch {
+        return value;
+    }
+    const markers = [parsed.origin, `//${parsed.host}`, parsed.host];
+    if (parsed.pathname !== "/")
+        markers.push(parsed.pathname);
+    const candidatePattern = new RegExp(`(?:${markers.map(escapeRegExp).join("|")})[^\\s<>"']*`, "gu");
+    return value
+        .replace(candidatePattern, (candidate) => sanitizeSameOriginTitleUrl(candidate, parsed))
+        .slice(0, 16_384);
+};
+const sanitizeSameOriginTitleUrl = (candidate, target) => {
+    let parsed;
+    try {
+        parsed = candidate.startsWith("//")
+            ? new URL(`${target.protocol}${candidate}`)
+            : candidate.startsWith(target.host)
+                ? new URL(`${target.protocol}//${candidate}`)
+                : new URL(candidate, target.origin);
+    }
+    catch {
+        return candidate;
+    }
+    return parsed.origin === target.origin && parsed.search !== ""
+        ? sanitizeBrowserUrl(parsed.href).url
+        : candidate;
 };
+const escapeRegExp = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 /** Select a browser attachment socket or a direct socket for one page target. */
 export const cdpTargetWebSocket = (discovery, target, operation) => {
     const webSocket = availableCdpTargetWebSocket(discovery, target);

package/dist/catalogIdentity.js

@@ -26,11 +26,13 @@ const promptCatalog = PROMPT_CONTRACTS.map((contract) => ({
     arguments: contract.arguments,
     steps: contract.steps,
 })).sort((left, right) => left.name.localeCompare(right.name));
-const resourceCatalog = [
+/** Canonical fixed resources exposed by every target-free MCP session. */
+export const MCP_RESOURCE_CATALOG = [
     { name: "server-identity", uri: "rea://server/identity" },
     { name: "active-residual-unknowns", uri: "rea://unknowns/active" },
 ];
-const resourceTemplateCatalog = [
+/** Canonical resource templates exposed by every target-free MCP session. */
+export const MCP_RESOURCE_TEMPLATE_CATALOG = [
     { name: "session-evidence", uri_template: "rea://evidence/{evidenceId}" },
     {
         name: "evidence-section",
@@ -57,6 +59,10 @@ const resourceTemplateCatalog = [
         name: "reconstruction-coverage-revision",
         uri_template: "rea://reconstruction-coverage/{workspaceId}/revision/{revision}",
     },
+    {
+        name: "javascript-application-graph-page",
+        uri_template: "rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}",
+    },
 ];
 const digest = (value) => {
     const encoded = canonicalize(value);
@@ -70,19 +76,22 @@ export const CATALOG_IDENTITY = {
         cli_commands: CLI_COMMAND_NAMES.length,
         mcp_tools: toolCatalog.length,
         mcp_prompts: promptCatalog.length,
-        mcp_resources: resourceCatalog.length,
-        mcp_resource_templates: resourceTemplateCatalog.length,
+        mcp_resources: MCP_RESOURCE_CATALOG.length,
+        mcp_resource_templates: MCP_RESOURCE_TEMPLATE_CATALOG.length,
     },
     digests: {
         tools_sha256: digest(toolCatalog),
         prompts_sha256: digest(promptCatalog),
-        resources_sha256: digest({ resourceCatalog, resourceTemplateCatalog }),
+        resources_sha256: digest({
+            resourceCatalog: MCP_RESOURCE_CATALOG,
+            resourceTemplateCatalog: MCP_RESOURCE_TEMPLATE_CATALOG,
+        }),
         combined_sha256: digest({
             cli: CLI_COMMAND_NAMES,
             tools: toolCatalog,
             prompts: promptCatalog,
-            resources: resourceCatalog,
-            resource_templates: resourceTemplateCatalog,
+            resources: MCP_RESOURCE_CATALOG,
+            resource_templates: MCP_RESOURCE_TEMPLATE_CATALOG,
         }),
     },
     tools: toolCatalog.map(({ name, surface, effects, annotations }) => ({

package/dist/cli/coreAnalysisCommands.js

@@ -1,8 +1,11 @@
 import { z } from "incur";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
 import { runDirectAnalysis } from "../application/DirectAnalysis.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { directAnalysisOptions, providerSelectionOption } from "./options.js";
+import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 export const registerCoreAnalysisCommands = (cli, logger) => {
     registerCoreCommands(cli, logger);
     registerFunctionCommand(cli, logger);
@@ -30,13 +33,19 @@ const registerCoreCommands = (cli, logger) => {
             .describe("Load and update a local analysis snapshot"),
         provider: providerSelectionOption,
     });
+    const analyzeOptions = overviewOptions.extend({
+        approved: z
+            .boolean()
+            .default(false)
+            .describe("Approve static analysis when the path is a JavaScript directory or ASAR"),
+    });
     cli.command(CLI_COMMANDS.analyze, {
         description: "Get an overview of an app",
         args: z.object({
             path: z.string().describe("App, program, or analysis database path"),
         }),
-        options: overviewOptions,
-        run: ({ args, options }) => logCliCommand(logger, "analyze", () => runDirectAnalysis(args.path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        options: analyzeOptions,
+        run: ({ args, options }) => logCliCommand(logger, "analyze", () => runRoutedOverview(args.path, options, logger)),
     });
     cli.command(CLI_COMMANDS.inspect, {
         description: "Inspect an app overview with evidence",
@@ -63,6 +72,29 @@ const registerCoreCommands = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
     });
 };
+const runRoutedOverview = async (path, options, logger) => {
+    if (options.provider === undefined &&
+        options.snapshot === undefined &&
+        (await isJavaScriptApplicationPath(path)))
+        return runCliJavaScriptApplicationAnalysis({
+            input_path: resolve(path),
+            approved: options.approved,
+        });
+    return runDirectAnalysis(path, "binary_overview", { detail: options.detail, limit: options.limit }, directAnalysisOptions(logger, options.snapshot, options.provider));
+};
+const isJavaScriptApplicationPath = async (path) => {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".asar"))
+        return true;
+    if (lower.endsWith(".app"))
+        return false;
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
 const registerXrefsCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.xrefs, {
         description: "List bounded references to an analyzed address",

package/dist/cli/javascriptApplicationAnalysis.js

@@ -0,0 +1,19 @@
+import { analyzeJavaScriptApplication } from "../application/JavaScriptApplicationService.js";
+import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
+import { parseConfig } from "../config.js";
+import { projectAnalysisError } from "../domain/errors.js";
+/** Execute the shared one-shot CLI boundary for static JavaScript analysis. */
+export const runCliJavaScriptApplicationAnalysis = async (input) => {
+    const config = parseConfig(process.env);
+    if (!config.ok)
+        return cliError(config.error);
+    const authority = await loadConfiguredPermissionAuthority(config.value);
+    if (!authority.ok)
+        return cliError(authority.error);
+    const result = await analyzeJavaScriptApplication(authority.value, input);
+    return result.ok ? result.value : cliError(result.error);
+};
+const cliError = (error) => ({
+    error: "JavaScript application analysis failed",
+    ...projectAnalysisError(error),
+});