rea-agents 2.3.0 → 2.5.0

package/dist/hopper/HopperClient.js

@@ -2,21 +2,22 @@ import { randomBytes, randomUUID } from "node:crypto";
 import { access } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperStartError, hopperStartupFailure, HopperTimeoutError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, HopperCancelledError, HopperProcessError, HopperProtocolError, HopperRemoteError, HopperStartError, hopperStartupFailure, HopperTimeoutError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { silentLogger } from "../logger.js";
-import { PendingOperations } from "../process/PendingOperations.js";
 import { PrivateRuntimeRoot } from "../process/PrivateRuntimeRoot.js";
 import { ProviderStartupDeadline } from "../process/ProviderDeadline.js";
 import { ProviderRunLineage } from "../process/ProviderRunLineage.js";
 import { ProviderProcessSupervisor, } from "../process/ProviderProcess.js";
-import { createOwnedHopperShutdownDiagnostic, providerCleanupFailure, } from "./HopperDiagnostics.js";
-import { isHopperCleanupRequired, isHopperShutdownAcknowledgement, parseHopperServerInfo, } from "./HopperSessionValues.js";
+import { cleanupHopperSession } from "./HopperCleanup.js";
+import { parseHopperServerInfo, } from "./HopperSessionValues.js";
 import { connectHopperSocketOnce } from "./HopperSocketConnection.js";
 import { hopperLauncherFailureDiagnostic } from "./HopperProcessDiagnostic.js";
-import { parseResponseLine, responseResult } from "./protocol.js";
-const MAX_LINE_BYTES = 10 * 1024 * 1024;
+import { HopperRequestQueue, } from "./HopperRequestQueue.js";
+import { HopperResponseStream } from "./HopperResponseStream.js";
+import { responseResult } from "./protocol.js";
 const SHUTDOWN_TIMEOUT_MS = 30_000;
+const MAX_QUEUED_REQUESTS = 64;
 const SESSION_ROOT = process.platform === "darwin" ? "/tmp" : tmpdir();
 /** Safe launcher telemetry; stderr content is intentionally never exposed. */
 /**
@@ -29,7 +30,8 @@ const SESSION_ROOT = process.platform === "darwin" ? "/tmp" : tmpdir();
  */
 export class HopperClient {
     #options;
-    #pending = new PendingOperations();
+    #requests;
+    #responses;
     #logger;
     #socket;
     #launch;
@@ -38,7 +40,6 @@ export class HopperClient {
     #token;
     #lineage = new ProviderRunLineage();
     #nextId = 1;
-    #buffer = "";
     #closing = false;
     #launcherExitCode;
     #launcherFailureDiagnostic;
@@ -46,7 +47,7 @@ export class HopperClient {
     #startPromise;
     #closePromise;
     #onSocketData = (chunk) => {
-        this.#onData(chunk);
+        this.#responses.push(chunk);
     };
     #onSocketError = () => {
         this.#failAll(new HopperProcessError(null));
@@ -62,11 +63,33 @@ export class HopperClient {
             requestTimeoutMs: options.requestTimeoutMs ?? 30_000,
             startupTimeoutMs: options.startupTimeoutMs ?? 120_000,
         };
+        this.#requests = new HopperRequestQueue(MAX_QUEUED_REQUESTS, ({ id, method, params }, failed) => {
+            const socket = this.#socket;
+            const token = this.#token;
+            if (socket === undefined || socket.destroyed || token === undefined) {
+                failed();
+                return;
+            }
+            socket.write(`${JSON.stringify({ id, token, method, params })}\n`, (cause) => {
+                if (cause !== undefined && cause !== null)
+                    failed();
+            });
+        });
+        this.#responses = new HopperResponseStream({
+            accept: (response) => this.#requests.accept(response.id, responseResult(response)),
+            hasQueued: (id) => this.#requests.hasQueued(id),
+            nextRequestId: () => this.#nextId,
+            abort: (message, cause) => this.#abortProtocol(message, cause),
+        });
     }
     /** Latest token-verified launcher lineage for the active run. */
     runtimeLineage() {
         return this.#lineage.snapshot();
     }
+    /** Observe a request that still occupies Hopper after caller timeout/cancel. */
+    requestActivity() {
+        return this.#requests.activity();
+    }
     /** Launch the bridge once and complete its authenticated health handshake. */
     start(signal) {
         if (this.#closePromise !== undefined) {
@@ -186,20 +209,29 @@ export class HopperClient {
         const started = await this.start(options.signal);
         if (!started.ok)
             return started;
-        return this.#request(name, arguments_, options);
+        const result = await this.#request(name, arguments_, options);
+        return !result.ok &&
+            result.error instanceof HopperRemoteError &&
+            result.error.diagnosticType === "capability_unavailable"
+            ? err(new AnalysisCapabilityUnavailableError("hopper", name, result.error.safeMessage))
+            : result;
     }
     /** Stop the bridge, settle outstanding requests, and remove session artifacts. */
     close() {
+        return this.closeWithOutcome().then(() => undefined);
+    }
+    /** Stop the bridge and report whether every owned resource was verified clean. */
+    closeWithOutcome(options = {}) {
         const starting = this.#startPromise;
         const controller = this.#startupController;
         controller?.abort();
-        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, controller));
+        this.#closePromise ??= Promise.resolve().then(() => this.#close(starting, controller, options));
         return this.#closePromise;
     }
-    async #close(starting, controller) {
+    async #close(starting, controller, options) {
         try {
             await starting?.catch(() => undefined);
-            await this.#cleanup();
+            return await this.#cleanup(options);
         }
         finally {
             if (this.#startPromise === starting)
@@ -210,63 +242,39 @@ export class HopperClient {
             this.#closePromise = undefined;
         }
     }
-    async #cleanup() {
+    async #cleanup(options = {}) {
         this.#closing = true;
         try {
-            const socket = this.#socket;
-            let cleanupResult;
-            if (socket !== undefined && !socket.destroyed) {
-                const shutdown = await this.#request("shutdown", {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS }).catch(() => err(new HopperProcessError(null)));
-                if (shutdown.ok &&
-                    isHopperCleanupRequired(shutdown.value) &&
-                    this.#launch?.shutdownByCleanup === true &&
-                    this.#launch.cleanup !== undefined) {
-                    cleanupResult = await this.#launch
-                        .cleanup()
-                        .catch(providerCleanupFailure);
-                    if (!cleanupResult.cleaned) {
-                        await this.#fallbackDocumentShutdown();
-                        cleanupResult = await this.#launch
-                            .cleanup()
-                            .catch(providerCleanupFailure);
-                    }
-                }
-                else if (!shutdown.ok ||
-                    !isHopperShutdownAcknowledgement(shutdown.value))
-                    this.#logger.warn({ status: shutdown.ok ? "invalid-acknowledgement" : "failed" }, "Hopper document shutdown was not confirmed");
-            }
-            this.#failAll(new HopperProcessError(null));
-            if (socket !== undefined)
-                this.#detachSocket(socket);
-            socket?.destroy();
+            return await cleanupHopperSession({
+                socket: this.#socket,
+                launch: this.#launch,
+                processSupervisor: this.#process,
+                runtimeRoot: this.#runtimeRoot,
+                activeRequest: this.#requests.activity(),
+                progress: options.progress,
+                logger: this.#logger,
+                onDiagnostic: this.#options.onDiagnostic,
+                request: (method) => this.#request(method, {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS }),
+                releaseTransport: (socket) => {
+                    this.#failAll(new HopperProcessError(null));
+                    if (socket !== undefined)
+                        this.#detachSocket(socket);
+                    socket?.destroy();
+                },
+            });
+        }
+        finally {
             this.#socket = undefined;
-            if (this.#process !== undefined) {
-                const stopped = await this.#process.stop(cleanupResult === undefined ? {} : { cleanupResult });
-                const diagnostic = createOwnedHopperShutdownDiagnostic(this.#process.launch, stopped, cleanupResult);
-                this.#options.onDiagnostic?.(diagnostic);
-                this.#logger.info(diagnostic, "Owned Hopper launcher shutdown completed");
-                if (stopped.status === "incomplete")
-                    this.#logger.warn({ reason: stopped.reason }, "Owned launcher cleanup failed closed");
-            }
             this.#process = undefined;
             this.#launch = undefined;
-            const runtimeRoot = this.#runtimeRoot;
             this.#runtimeRoot = undefined;
-            await runtimeRoot?.close();
             this.#token = undefined;
-            this.#buffer = "";
+            this.#responses.reset();
             this.#launcherExitCode = undefined;
             this.#launcherFailureDiagnostic = undefined;
-        }
-        finally {
             this.#closing = false;
         }
     }
-    async #fallbackDocumentShutdown() {
-        const fallback = await this.#request("shutdown_document", {}, { timeoutMs: SHUTDOWN_TIMEOUT_MS }).catch(() => err(new HopperProcessError(null)));
-        if (!fallback.ok || !isHopperShutdownAcknowledgement(fallback.value))
-            this.#logger.warn({ status: fallback.ok ? "invalid-acknowledgement" : "failed" }, "Hopper document shutdown fallback was not confirmed");
-    }
     async #connect(socketPath, deadline) {
         while (deadline.remainingMs() > 0) {
             if (deadline.signal.aborted)
@@ -306,17 +314,11 @@ export class HopperClient {
         const id = this.#nextId++;
         const startedAt = performance.now();
         const timeoutMs = options.timeoutMs ?? this.#options.requestTimeoutMs;
-        const response = this.#pending.wait(id, {
+        const result = await this.#requests.run(id, method, params, {
             timeoutMs,
             ...(options.signal === undefined ? {} : { signal: options.signal }),
-            timeoutValue: () => err(new HopperTimeoutError(timeoutMs)),
-            cancelledValue: () => err(new HopperCancelledError()),
+            ...(options.progress !== undefined ? { progress: options.progress } : {}),
         });
-        socket.write(`${JSON.stringify({ id, token, method, params })}\n`, (cause) => {
-            if (cause !== undefined && cause !== null)
-                this.#pending.settle(id, err(new HopperProcessError(null)));
-        });
-        const result = await response;
         this.#logger[result.ok ? "debug" : "warn"]({
             method,
             durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
@@ -364,44 +366,12 @@ export class HopperClient {
         if (launch.ownsProcessLifetime && !this.#closing)
             this.#failAll(new HopperProcessError(event.code, this.#launcherFailureDiagnostic));
     }
-    #onData(chunk) {
-        this.#buffer += chunk;
-        let newline = this.#buffer.indexOf("\n");
-        while (newline >= 0) {
-            const line = this.#buffer.slice(0, newline).trim();
-            this.#buffer = this.#buffer.slice(newline + 1);
-            if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
-                this.#abortProtocol("Hopper response exceeded the maximum line size");
-                return;
-            }
-            if (line.length > 0)
-                this.#onLine(line);
-            newline = this.#buffer.indexOf("\n");
-        }
-        if (Buffer.byteLength(this.#buffer) > MAX_LINE_BYTES) {
-            this.#abortProtocol("Hopper response exceeded the maximum line size");
-        }
-    }
-    #onLine(line) {
-        const parsed = parseResponseLine(line);
-        if (!parsed.ok) {
-            this.#abortProtocol(parsed.error.message, parsed.error);
-            return;
-        }
-        if (!this.#pending.has(parsed.value.id)) {
-            if (parsed.value.id >= this.#nextId) {
-                this.#abortProtocol("Hopper returned an unknown response id");
-            }
-            return;
-        }
-        this.#pending.settle(parsed.value.id, responseResult(parsed.value));
-    }
     #abortProtocol(message, cause) {
         this.#failAll(new HopperProtocolError(message, { cause }));
         this.#socket?.destroy();
     }
     #failAll(error) {
-        this.#pending.failAll(() => err(error));
+        this.#requests.failAll(error);
     }
 }
 const isAborted = (signal) => signal?.aborted === true;

package/dist/hopper/HopperProvider.js

@@ -47,7 +47,7 @@ const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract)
     }),
     limits: Object.freeze({
         maxResults: null,
-        maxPayloadBytes: null,
+        maxPayloadBytes: contract.name === "read_bytes" ? 4_096 : null,
         timeoutMs: null,
     }),
     limitations: Object.freeze([
@@ -200,6 +200,25 @@ export class HopperProvider {
                     ? []
                     : [{ provider: executionProvider, observation }];
             },
+            requestActivitySnapshots: () => {
+                const activity = client.requestActivity();
+                return [
+                    {
+                        provider: executionProvider,
+                        active: activity === null
+                            ? null
+                            : {
+                                requestId: activity.requestId,
+                                operation: activity.operation,
+                                elapsedMs: activity.elapsedMs,
+                                timeoutMs: activity.timeoutMs,
+                                callerState: activity.callerState,
+                            },
+                        queuedRequests: activity?.queuedRequests ?? 0,
+                    },
+                ];
+            },
+            closeWithOutcome: (options) => client.closeWithOutcome(options),
             close: () => client.close(),
         };
     }

package/dist/hopper/HopperRequestQueue.js

@@ -0,0 +1,187 @@
+import { performance } from "node:perf_hooks";
+import { HopperCancelledError, HopperProcessError, HopperProtocolError, HopperTimeoutError, } from "../domain/errors.js";
+import { err } from "../domain/result.js";
+/** Bounded FIFO that keeps the wire serialized until Hopper actually replies. */
+export class HopperRequestQueue {
+    maximum;
+    send;
+    #queue = [];
+    #active;
+    constructor(maximum, send) {
+        this.maximum = maximum;
+        this.send = send;
+    }
+    /** Queue one request, counting queue wait against its caller deadline. */
+    run(id, method, params, options) {
+        if (options.signal?.aborted === true)
+            return Promise.resolve(err(new HopperCancelledError()));
+        if (options.timeoutMs <= 0)
+            return Promise.resolve(err(new HopperTimeoutError(options.timeoutMs)));
+        if (this.#size() >= this.maximum)
+            return Promise.resolve(err(new HopperProtocolError(`Hopper serial request queue reached its ${String(this.maximum)}-request limit`)));
+        return new Promise((resolve) => {
+            let entry;
+            const onAbort = options.signal === undefined ? undefined : () => this.#cancel(entry);
+            const timer = setTimeout(() => this.#timeout(entry), options.timeoutMs);
+            entry = {
+                id,
+                method,
+                params,
+                signal: options.signal,
+                timeoutMs: options.timeoutMs,
+                deadline: performance.now() + options.timeoutMs,
+                progress: options.progress,
+                resolve,
+                timer,
+                onAbort,
+                callerState: "waiting",
+                callerSettled: false,
+                startedAt: undefined,
+                heartbeat: undefined,
+            };
+            this.#queue.push(entry);
+            if (onAbort !== undefined)
+                options.signal?.addEventListener("abort", onAbort, { once: true });
+            if (this.#active !== undefined || this.#queue.length > 1)
+                this.#report(entry, `${method} queued behind ${String(this.#size() - 1)} Hopper request(s)`);
+            this.#drain();
+        });
+    }
+    /** Settle the active wire request. False identifies an unexpected response id. */
+    accept(id, result) {
+        const entry = this.#active;
+        if (entry === undefined || entry.id !== id)
+            return false;
+        this.#releaseWire(entry);
+        if (!entry.callerSettled)
+            this.#settleCaller(entry, result, "waiting");
+        this.#active = undefined;
+        this.#drain();
+        return true;
+    }
+    /** Fail the active wire request and every request still waiting in the FIFO. */
+    failAll(error) {
+        const active = this.#active;
+        this.#active = undefined;
+        if (active !== undefined) {
+            this.#releaseWire(active);
+            if (!active.callerSettled)
+                this.#settleCaller(active, err(error), "waiting");
+        }
+        for (const entry of this.#queue.splice(0))
+            this.#settleCaller(entry, err(error), "waiting");
+    }
+    /** Snapshot the one request still occupying Hopper's serial Python thread. */
+    activity() {
+        const active = this.#active;
+        if (active === undefined || active.startedAt === undefined)
+            return null;
+        return {
+            requestId: active.id,
+            operation: active.method,
+            elapsedMs: Math.max(0, Math.round(performance.now() - active.startedAt)),
+            timeoutMs: active.timeoutMs,
+            callerState: active.callerState,
+            queuedRequests: this.#queue.length,
+        };
+    }
+    /** Return whether an id belongs to a request that has not crossed the wire. */
+    hasQueued(id) {
+        return this.#queue.some((entry) => entry.id === id);
+    }
+    /** Number of caller requests waiting behind the active bridge operation. */
+    queuedCount() {
+        return this.#queue.length;
+    }
+    #size() {
+        return this.#queue.length + (this.#active === undefined ? 0 : 1);
+    }
+    #drain() {
+        if (this.#active !== undefined)
+            return;
+        const entry = this.#queue.shift();
+        if (entry === undefined)
+            return;
+        const remaining = entry.deadline - performance.now();
+        if (entry.signal?.aborted === true || remaining <= 0) {
+            this.#settleCaller(entry, entry.signal?.aborted === true
+                ? err(new HopperCancelledError())
+                : err(new HopperTimeoutError(entry.timeoutMs)), entry.signal?.aborted === true ? "cancelled" : "timed_out");
+            this.#drain();
+            return;
+        }
+        this.#active = entry;
+        entry.startedAt = performance.now();
+        this.#report(entry, `${entry.method} started on Hopper's serial bridge`);
+        entry.heartbeat = setInterval(() => {
+            if (entry.callerSettled || entry.startedAt === undefined)
+                return;
+            const elapsed = Math.round(performance.now() - entry.startedAt);
+            this.#report(entry, `${entry.method} is still running in Hopper (${String(elapsed)} ms elapsed)`);
+        }, 1_000);
+        try {
+            this.send({ id: entry.id, method: entry.method, params: entry.params }, () => this.accept(entry.id, err(new HopperProcessError(null))));
+        }
+        catch (cause) {
+            this.accept(entry.id, err(new HopperProtocolError("Hopper socket write failed", { cause })));
+        }
+    }
+    #timeout(entry) {
+        if (entry.callerSettled)
+            return;
+        if (this.#active === entry) {
+            this.#settleCaller(entry, err(new HopperTimeoutError(entry.timeoutMs)), "timed_out");
+            return;
+        }
+        const index = this.#queue.indexOf(entry);
+        if (index < 0)
+            return;
+        this.#queue.splice(index, 1);
+        this.#settleCaller(entry, err(new HopperTimeoutError(entry.timeoutMs)), "timed_out");
+    }
+    #cancel(entry) {
+        if (entry.callerSettled)
+            return;
+        if (this.#active === entry) {
+            this.#settleCaller(entry, err(new HopperCancelledError()), "cancelled");
+            return;
+        }
+        const index = this.#queue.indexOf(entry);
+        if (index < 0)
+            return;
+        this.#queue.splice(index, 1);
+        this.#settleCaller(entry, err(new HopperCancelledError()), "cancelled");
+    }
+    #settleCaller(entry, result, callerState) {
+        if (entry.callerSettled)
+            return;
+        entry.callerSettled = true;
+        entry.callerState = callerState;
+        if (this.#active === entry && entry.heartbeat !== undefined) {
+            clearInterval(entry.heartbeat);
+            entry.heartbeat = undefined;
+        }
+        clearTimeout(entry.timer);
+        if (entry.signal !== undefined && entry.onAbort !== undefined)
+            entry.signal.removeEventListener("abort", entry.onAbort);
+        entry.resolve(result);
+    }
+    #releaseWire(entry) {
+        if (entry.heartbeat !== undefined)
+            clearInterval(entry.heartbeat);
+        entry.heartbeat = undefined;
+        clearTimeout(entry.timer);
+        if (entry.signal !== undefined && entry.onAbort !== undefined)
+            entry.signal.removeEventListener("abort", entry.onAbort);
+    }
+    #report(entry, message) {
+        void entry.progress
+            ?.report({
+            phase: "hopper_request",
+            completed: 0,
+            total: 1,
+            message,
+        })
+            .catch(() => undefined);
+    }
+}

package/dist/hopper/HopperResponseStream.js

@@ -0,0 +1,46 @@
+import { parseResponseLine } from "./protocol.js";
+const MAX_LINE_BYTES = 10 * 1024 * 1024;
+/** Incrementally validates bounded Hopper NDJSON response frames. */
+export class HopperResponseStream {
+    options;
+    #buffer = "";
+    constructor(options) {
+        this.options = options;
+    }
+    push(chunk) {
+        this.#buffer += chunk;
+        let newline = this.#buffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
+                this.options.abort("Hopper response exceeded the maximum line size");
+                return;
+            }
+            if (line.length > 0 && !this.#acceptLine(line))
+                return;
+            newline = this.#buffer.indexOf("\n");
+        }
+        if (Buffer.byteLength(this.#buffer) > MAX_LINE_BYTES) {
+            this.options.abort("Hopper response exceeded the maximum line size");
+        }
+    }
+    reset() {
+        this.#buffer = "";
+    }
+    #acceptLine(line) {
+        const parsed = parseResponseLine(line);
+        if (!parsed.ok) {
+            this.options.abort(parsed.error.message, parsed.error);
+            return false;
+        }
+        if (this.options.accept(parsed.value))
+            return true;
+        if (parsed.value.id >= this.options.nextRequestId() ||
+            this.options.hasQueued(parsed.value.id)) {
+            this.options.abort("Hopper returned an unknown response id");
+            return false;
+        }
+        return true;
+    }
+}

package/dist/hopper/protocol.js

@@ -17,6 +17,7 @@ const responseSchema = z.union([
                 "remote",
                 "authorization",
                 "invalid_request",
+                "capability_unavailable",
                 "bridge_exception",
             ])
                 .default("remote"),

package/dist/main/transport.js

@@ -14,35 +14,14 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
                 analysisSnapshotFilePolicy: serverContext.runtimeState.snapshotPolicy,
                 permissionAuthority: serverContext.permissionAuthority,
                 browserObservation: serverContext.browserObservation,
+                browserScenarioCapture: serverContext.browserScenarioCapture,
                 electronObservation: serverContext.electronObservation,
+                javascriptRuntimeObservation: serverContext.javascriptRuntimeObservation,
                 artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
                     .artifactIntegrityContinueEnabled,
                 javascriptReplayPolicy: serverContext.runtimeState.javascriptReplayPolicy,
                 managedRuntimePolicy: serverContext.runtimeState.managedRuntimePolicy,
-                availabilityPolicy: () => ({
-                    processCaptureEnabled: serverContext.runtimeState.currentConfig.processExecutionPolicy
-                        .enabled,
-                    evidenceFileRoots: serverContext.runtimeState.currentConfig.evidenceFilePolicy
-                        .roots.length,
-                    investigationInputRoots: serverContext.runtimeState.currentConfig.investigationInputRoots
-                        .length,
-                    browserObservationEnabled: serverContext.runtimeState.currentConfig
-                        .browserObservationEnabled &&
-                        serverContext.runtimeState.currentConfig.browserCdpEndpoints
-                            .length > 0 &&
-                        serverContext.runtimeState.currentConfig.browserAllowedOrigins
-                            .length > 0,
-                    electronObservationEnabled: serverContext.runtimeState.currentConfig
-                        .electronObservationEnabled &&
-                        serverContext.runtimeState.currentConfig.electronCdpEndpoints
-                            .length > 0 &&
-                        serverContext.runtimeState.currentConfig.electronFileRoots
-                            .length > 0,
-                    javascriptReplayEnabled: serverContext.runtimeState.currentConfig.javascriptReplayPolicy
-                        .enabled,
-                    managedRuntimeEnabled: serverContext.runtimeState.currentConfig.managedRuntimePolicy
-                        .enabled,
-                }),
+                availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
             });
             liveServers.add(server);
             return server;
@@ -61,3 +40,24 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     }
     return { ok: true, handle, liveServers };
 };
+const runtimeAvailability = (state) => ({
+    processCaptureEnabled: state.currentConfig.processExecutionPolicy.enabled,
+    evidenceFileRoots: state.currentConfig.evidenceFilePolicy.roots.length,
+    investigationInputRoots: state.currentConfig.investigationInputRoots.length,
+    browserObservationEnabled: state.currentConfig.browserObservationEnabled &&
+        state.currentConfig.browserCdpEndpoints.length > 0 &&
+        state.currentConfig.browserAllowedOrigins.length > 0,
+    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.enabled &&
+        state.currentConfig.browserScenarioPolicy.allowedOrigins.length > 0 &&
+        (state.currentConfig.browserScenarioPolicy.executableRoots.length > 0 ||
+            state.currentConfig.browserScenarioPolicy.cdpEndpoints.length > 0),
+    electronObservationEnabled: state.currentConfig.electronObservationEnabled &&
+        state.currentConfig.electronCdpEndpoints.length > 0 &&
+        state.currentConfig.electronFileRoots.length > 0,
+    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationEnabled &&
+        state.currentConfig.v8InspectorEndpoints.length > 0 &&
+        (state.currentConfig.v8InspectorFileRoots.length > 0 ||
+            state.currentConfig.v8InspectorAllowedOrigins.length > 0),
+    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.enabled,
+    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.enabled,
+});

package/dist/main.js

@@ -9,6 +9,8 @@ import { projectAnalysisError } from "./domain/errors.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
 import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
+import { V8InspectorProvider } from "./browser/V8InspectorProvider.js";
+import { PlaywrightBrowserScenarioProvider } from "./browser/PlaywrightBrowserScenarioProvider.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
 import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
@@ -59,7 +61,9 @@ export const run = async (dependencies = runtimeDependencies()) => {
     }
     const session = createBinarySession(config.value, logger);
     const browserObservation = new CdpBrowserProvider();
+    const browserScenarioCapture = new PlaywrightBrowserScenarioProvider();
     const electronObservation = new CdpElectronProvider();
+    const javascriptRuntimeObservation = new V8InspectorProvider();
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
         return opened.exitCode;
@@ -68,7 +72,9 @@ export const run = async (dependencies = runtimeDependencies()) => {
         logger,
         serverLogger,
         browserObservation,
+        browserScenarioCapture,
         electronObservation,
+        javascriptRuntimeObservation,
         permissionAuthority: permissionAuthority.value,
         runtimeState,
     });