rea-agents 3.1.0 → 3.2.0

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -4,7 +4,7 @@ import { redactSensitiveText } from "./SensitiveTextCapture.js";
 const OPERATION = "capture_electron_scenario";
 const hookEventSchema = z.strictObject({
     sequence: z.number().int().min(1),
-    correlation_id: z.string().max(256).nullable(),
+    correlation_id: z.string().nullable(),
     kind: z.enum([
         "main-handler-invocation",
         "main-event-invocation",
@@ -30,10 +30,9 @@ const hookEventSchema = z.strictObject({
         "updater",
         "error",
     ]),
-    event: z.string().max(128).nullable(),
+    event: z.string().nullable(),
     phase: z.enum(["attempted", "completed", "blocked", "failed", "observed"]),
-    channel: z.string().max(1_024).nullable(),
-    channel_truncated: z.boolean().default(false),
+    channel: z.string().nullable(),
     direction: z
         .enum([
         "renderer-to-main",
@@ -42,17 +41,16 @@ const hookEventSchema = z.strictObject({
         "utility-to-main",
     ])
         .nullable(),
-    sender: z.string().max(256).nullable(),
-    receiver: z.string().max(256).nullable(),
-    frame: z.string().max(256).nullable(),
-    target: z.string().max(256).nullable(),
-    argument_shapes: z.array(z.string().max(64)).max(32),
-    argument_shapes_truncated: z.boolean().default(false),
-    result_shape: z.string().max(64).nullable(),
-    process_type: z.string().max(128).nullable(),
-    source: z.string().max(64),
+    sender: z.string().nullable(),
+    receiver: z.string().nullable(),
+    frame: z.string().nullable(),
+    target: z.string().nullable(),
+    argument_shapes: z.array(z.string()),
+    result_shape: z.string().nullable(),
+    process_type: z.string().nullable(),
+    source: z.string(),
     capture_method: z.enum(["api-wrapper", "event-emitter", "process-hook"]),
-    artifact_path: z.string().max(16_384).nullable(),
+    artifact_path: z.string().nullable(),
     artifact_sha256: z
         .string()
         .regex(/^[a-f0-9]{64}$/u)
@@ -60,27 +58,26 @@ const hookEventSchema = z.strictObject({
     error: z.boolean(),
 });
 const hookSnapshotSchema = z.strictObject({
-    events: z.array(hookEventSchema).max(20_000),
+    events: z.array(hookEventSchema),
     observed: z.number().int().min(0),
     observed_ipc: z.number().int().min(0),
     observed_runtime: z.number().int().min(0),
-    truncated: z.boolean(),
     hook_error: z.boolean(),
 });
 const metricSchema = z.strictObject({
     pid: z.number().int().min(1),
-    type: z.string().min(1).max(128),
-    name: z.string().max(256).nullable(),
-    service_name: z.string().max(256).nullable(),
+    type: z.string().min(1),
+    name: z.string().nullable(),
+    service_name: z.string().nullable(),
 });
 const windowMetadataSchema = z.strictObject({
-    window_id: z.string().max(256),
-    web_contents_id: z.string().max(256),
+    window_id: z.string(),
+    web_contents_id: z.string(),
     visible: z.boolean().nullable(),
     destroyed: z.boolean(),
 });
-/** Run bounded, explicit actions against provider-owned Electron windows. */
-export const runElectronActions = async (application, input, options, deadline) => {
+/** Run explicit actions against provider-owned Electron windows. */
+export const runElectronActions = async (application, input, options) => {
     const actions = [];
     for (const action of input.actions) {
         if (options.signal?.aborted === true)
@@ -89,18 +86,13 @@ export const runElectronActions = async (application, input, options, deadline)
         const windowIndex = actionWindowIndex(action);
         let selectedWindow;
         try {
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                throw new BrowserObservationError(OPERATION, "timeout");
             selectedWindow =
                 windowIndex === null
                     ? undefined
                     : await waitForWindow({
                         application,
                         windowIndex,
-                        timeout: input.limits.action_timeout_ms,
                         signal: options.signal,
-                        deadline,
                     });
             if ((action.kind === "click" ||
                 action.kind === "renderer-reload" ||
@@ -111,10 +103,7 @@ export const runElectronActions = async (application, input, options, deadline)
                 application,
                 action,
                 selectedWindow,
-                remaining,
-                actionTimeoutMs: input.limits.action_timeout_ms,
                 options,
-                deadline,
             });
             actions.push({
                 step_id: action.step_id,
@@ -141,31 +130,29 @@ export const runElectronActions = async (application, input, options, deadline)
     }
     return actions;
 };
-const runAction = async ({ application, action, selectedWindow, remaining, actionTimeoutMs, options, deadline, }) => {
+const runAction = async ({ application, action, selectedWindow, options, }) => {
     switch (action.kind) {
         case "click":
             if (selectedWindow === undefined)
                 throw new BrowserObservationError(OPERATION, "window_not_found");
             await runWithExecutionLimits(selectedWindow.locator(action.selector).click({
-                timeout: Math.min(actionTimeoutMs, remaining),
-            }), options.signal, deadline);
+                timeout: 0,
+            }), options.signal);
             return;
         case "wait": {
             const page = selectedWindow ??
                 (await application.firstWindow({
-                    timeout: Math.min(actionTimeoutMs, remaining),
+                    timeout: 0,
                 }));
-            await runWithExecutionLimits(page.waitForTimeout(Math.min(action.duration_ms, remaining)), options.signal, deadline);
-            if (action.duration_ms > remaining)
-                throw new BrowserObservationError(OPERATION, "timeout");
+            await runWithExecutionLimits(page.waitForTimeout(action.duration_ms), options.signal);
             return;
         }
         case "renderer-reload":
             if (selectedWindow === undefined)
                 throw new BrowserObservationError(OPERATION, "window_not_found");
             await runWithExecutionLimits(selectedWindow.reload({
-                timeout: Math.min(actionTimeoutMs, remaining),
-            }), options.signal, deadline);
+                timeout: 0,
+            }), options.signal);
             return;
         case "renderer-crash": {
             const crashed = await runWithExecutionLimits(application.evaluate(({ BrowserWindow }, index) => {
@@ -174,13 +161,13 @@ const runAction = async ({ application, action, selectedWindow, remaining, actio
                     return false;
                 candidate.webContents.forcefullyCrashRenderer();
                 return true;
-            }, action.window_index), options.signal, deadline);
+            }, action.window_index), options.signal);
             if (!crashed)
                 throw new BrowserObservationError(OPERATION, "window_not_found");
             return;
         }
         case "deep-link":
-            await runWithExecutionLimits(emitDeepLink(application, action), options.signal, deadline);
+            await runWithExecutionLimits(emitDeepLink(application, action), options.signal);
             return;
     }
 };
@@ -196,31 +183,29 @@ const actionWindowIndex = (action) => {
             return null;
     }
 };
-const waitForWindow = async ({ application, windowIndex, timeout, signal, deadline, }) => {
-    const stopAt = Math.min(deadline, Date.now() + timeout);
-    while (Date.now() < stopAt) {
+const waitForWindow = async ({ application, windowIndex, signal, }) => {
+    while (true) {
         if (signal?.aborted === true)
             throw new BrowserObservationError(OPERATION, "cancelled");
         const window = application.windows()[windowIndex];
         if (window !== undefined)
             return window;
-        await runWithExecutionLimits(new Promise((resolve) => setTimeout(resolve, 25)), signal, stopAt);
+        await runWithExecutionLimits(new Promise((resolve) => setTimeout(resolve, 25)), signal);
     }
-    throw new BrowserObservationError(OPERATION, "window_not_found");
 };
 const emitDeepLink = (application, action) => application.evaluate(({ app }, payload) => {
     if (payload.delivery === "open-url")
         return app.emit("open-url", { preventDefault: () => undefined }, payload.url);
     return app.emit("second-instance", {}, [payload.url], "", {});
 }, { delivery: action.delivery, url: action.url });
-/** Read the current Electron windows, metrics, and bounded hook snapshot. */
+/** Read the current Electron windows, metrics, and hook snapshot. */
 // oxlint-disable-next-line max-lines-per-function -- one state read must share one capture boundary.
-export const readApplicationState = async (application, maxWindows) => {
+export const readApplicationState = async (application) => {
     const pages = application.windows();
-    const pageSnapshotsPromise = Promise.all(pages.slice(0, maxWindows).map(async (page, index) => ({
+    const pageSnapshotsPromise = Promise.all(pages.map(async (page, index) => ({
         index,
-        url: page.url().slice(0, 65_536),
-        title: (await page.title()).slice(0, 16_384),
+        url: page.url(),
+        title: await page.title(),
     })));
     const windowMetadataPromise = application
         .evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows().map((window) => ({
@@ -253,7 +238,6 @@ export const readApplicationState = async (application, maxWindows) => {
                 observed: 0,
                 observed_ipc: 0,
                 observed_runtime: 0,
-                truncated: false,
                 hook_error: true,
             };
     })
@@ -279,32 +263,33 @@ export const readApplicationState = async (application, maxWindows) => {
                 destroyed: metadata.destroyed,
             };
         }),
-        windowsTruncated: pages.length > maxWindows,
         metrics: processMetrics,
         electronVersion,
         hookSnapshot,
     };
 };
-/** Apply a deadline and caller cancellation to one Playwright operation. */
+/** Apply an optional lifecycle deadline and caller cancellation to an operation. */
 export const runWithExecutionLimits = async (operation, signal, deadline) => {
     if (signal?.aborted === true)
         throw new BrowserObservationError(OPERATION, "cancelled");
+    if (signal === undefined && deadline === undefined)
+        return operation;
     let timer;
     let abortListener;
-    const timeout = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new BrowserObservationError(OPERATION, "timeout")), Math.max(1, deadline - Date.now()));
-    });
-    const cancellation = signal === undefined
-        ? timeout
-        : Promise.race([
-            timeout,
-            new Promise((_, reject) => {
-                abortListener = () => reject(new BrowserObservationError(OPERATION, "cancelled"));
-                signal.addEventListener("abort", abortListener, { once: true });
-            }),
-        ]);
+    const interruptions = [];
+    if (deadline !== undefined)
+        interruptions.push(new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new BrowserObservationError(OPERATION, "timeout")), Math.max(1, deadline - Date.now()));
+        }));
+    if (signal !== undefined)
+        interruptions.push(new Promise((_, reject) => {
+            abortListener = () => reject(new BrowserObservationError(OPERATION, "cancelled"));
+            signal.addEventListener("abort", abortListener, { once: true });
+        }));
     try {
-        return await Promise.race([operation, cancellation]);
+        return interruptions.length === 0
+            ? await operation
+            : await Promise.race([operation, ...interruptions]);
     }
     finally {
         if (timer !== undefined)
@@ -320,5 +305,5 @@ const safeActionErrorMessage = (cause, action) => {
         .sort((left, right) => right.length - left.length);
     for (const value of inputValues)
         message = message.split(value).join("<redacted-input>");
-    return redactSensitiveText(message).slice(0, 1_024);
+    return redactSensitiveText(message);
 };

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -9,6 +9,7 @@ import { err, ok } from "../domain/result.js";
 import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, observeOwnedProcessLineage, selectCapturedProcessGroupIds, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
 import { runElectronActions, readApplicationState, runWithExecutionLimits, } from "./PlaywrightElectronActiveActions.js";
 const OPERATION = "capture_electron_scenario";
+const STARTUP_TIMEOUT_MS = 60_000;
 /** Public identity for provider-owned Electron runtime experiments. */
 export const PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY = Object.freeze({
     id: "rea-playwright-electron-active",
@@ -78,11 +79,7 @@ const createCoverage = (hookSnapshot) => {
         unavailableEventFamilies.add("renderer-ipc");
     }
     return {
-        status: hookSnapshot.hook_error
-            ? "hook_conflict"
-            : hookSnapshot.truncated
-                ? "capture_truncated"
-                : "partial_attach",
+        status: hookSnapshot.hook_error ? "hook_conflict" : "partial_attach",
         observed_event_families: observedEventFamilies,
         unavailable_event_families: [...unavailableEventFamilies].sort(),
         observed_roles: observedRoles,
@@ -103,14 +100,14 @@ export class PlaywrightElectronActiveProvider {
         try {
             if (options.signal?.aborted === true)
                 throw new BrowserObservationError(OPERATION, "cancelled");
-            const deadline = Date.now() + input.limits.max_duration_ms;
+            const startupDeadline = Date.now() + STARTUP_TIMEOUT_MS;
             const paths = await canonicalPaths(input);
             application = await electron.launch({
                 executablePath: paths.executable,
                 cwd: paths.root,
-                env: safeElectronEnvironment(input.limits.max_ipc_events, input.limits.max_runtime_events, runId),
+                env: safeElectronEnvironment(runId),
                 args: ["-r", hookPath, paths.application, ...input.args],
-                timeout: Math.max(1, deadline - Date.now()),
+                timeout: Math.max(1, startupDeadline - Date.now()),
             });
             const leaderPid = application.process().pid;
             if (typeof leaderPid !== "number" ||
@@ -125,8 +122,8 @@ export class PlaywrightElectronActiveProvider {
                 expectedCommand: paths.executable,
                 sweepTokenOwnedProcesses: true,
             };
-            const actions = await runElectronActions(application, input, options, deadline);
-            const state = await runWithExecutionLimits(readApplicationState(application, input.limits.max_windows), options.signal, deadline);
+            const actions = await runElectronActions(application, input, options);
+            const state = await runWithExecutionLimits(readApplicationState(application), options.signal);
             outcome = ok(createResult(paths, input, actions, state));
         }
         catch (cause) {
@@ -211,7 +208,6 @@ const createResult = (paths, input, actions, state) => {
     const { hookSnapshot } = state;
     const ipcEvents = hookSnapshot.events.filter(({ kind }) => ipcEventKinds.has(kind));
     return electronActiveObservationResultSchema.parse({
-        schema_version: 1,
         application: {
             executable_path: paths.executable,
             application_path: paths.application,
@@ -220,37 +216,26 @@ const createResult = (paths, input, actions, state) => {
             cleanup: "terminated-owned-process",
         },
         actions,
-        windows: state.windows.slice(0, input.limits.max_windows),
-        windows_truncated: state.windowsTruncated,
+        windows: state.windows,
         processes: {
-            items: state.metrics.slice(0, input.limits.max_processes),
-            truncated: state.metrics.length > input.limits.max_processes,
+            items: state.metrics,
         },
         ipc: {
-            events: ipcEvents.slice(0, input.limits.max_ipc_events),
+            events: ipcEvents,
             observed: hookSnapshot.observed_ipc,
-            retained: Math.min(ipcEvents.length, input.limits.max_ipc_events),
-            truncated: hookSnapshot.truncated ||
-                ipcEvents.length > input.limits.max_ipc_events,
         },
         timeline: {
-            events: hookSnapshot.events.slice(0, input.limits.max_runtime_events),
+            events: hookSnapshot.events,
             observed: hookSnapshot.observed,
-            retained: Math.min(hookSnapshot.events.length, input.limits.max_runtime_events),
-            truncated: hookSnapshot.truncated ||
-                hookSnapshot.events.length > input.limits.max_runtime_events,
         },
         coverage: createCoverage(hookSnapshot),
         limitations: [
-            "IPC payloads are represented only by bounded value shapes; values are never retained, channels are capped at 1,024 characters, and argument-shape arrays at 32 entries.",
+            "IPC payloads are represented by value shapes; payload values are never retained.",
             "IPC direction and sender/receiver identifiers are observed only where Electron exposes them at the hooked boundary.",
-            "The runtime timeline records bounded lifecycle, navigation, shell, permission, popup, download, protocol, preload, native-addon, process, and IPC events; activity before hook installation is unavailable.",
+            "The runtime timeline records lifecycle, navigation, shell, permission, popup, download, protocol, preload, native-addon, process, and IPC events; activity before hook installation is unavailable.",
             "The preload and renderer process contexts are not instrumented by the main-process -r hook; preload configuration and contextBridge API-shape events are main-boundary observations, not proof of renderer-side execution.",
             "Process metrics are an Electron API snapshot and do not prove hostile-local-user isolation.",
             "External shell opens, external navigation, permission grants, downloads, popup windows, updater relaunches, and OS integration are blocked and recorded by the active hook; other application filesystem and network behavior is not sandboxed by this provider.",
-            ...(state.windowsTruncated
-                ? ["Windows beyond max_windows were not retained."]
-                : []),
             ...(hookSnapshot.hook_error
                 ? ["The active IPC hook could not be installed."]
                 : []),
@@ -267,7 +252,7 @@ const canonicalPaths = async (input) => {
         throw new BrowserObservationError(OPERATION, "target_not_allowed");
     return { executable, application, root };
 };
-const safeElectronEnvironment = (maxIpcEvents, maxRuntimeEvents, runId) => Object.fromEntries([
+const safeElectronEnvironment = (runId) => Object.fromEntries([
     ...[
         "HOME",
         "LANG",
@@ -280,11 +265,6 @@ const safeElectronEnvironment = (maxIpcEvents, maxRuntimeEvents, runId) => Objec
     ]
         .map((name) => [name, process.env[name]])
         .filter((entry) => entry[1] !== undefined),
-    ["REA_ELECTRON_ACTIVE_MAX_IPC_EVENTS", String(maxIpcEvents)],
-    [
-        "REA_ELECTRON_ACTIVE_MAX_RUNTIME_EVENTS",
-        String(maxRuntimeEvents),
-    ],
     ["REA_PROCESS_RUN_ID", runId],
 ]);
 const providerError = (cause) => cause instanceof AnalysisError

package/dist/browser/PlaywrightExecutionBoundary.js

@@ -1,13 +1,25 @@
 import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/errors.js";
 const OPERATION = "capture_browser_scenario";
-export const withPlaywrightExecutionBoundary = (work, maximumTimeoutMs, signal) => {
-    if (maximumTimeoutMs <= 0)
-        return Promise.reject(new AnalysisTimeoutError(OPERATION, maximumTimeoutMs));
+export const withPlaywrightExecutionBoundary = (work, timeoutMs, signal) => {
+    if (timeoutMs !== undefined && timeoutMs <= 0)
+        return Promise.reject(new AnalysisTimeoutError(OPERATION, timeoutMs));
     if (signal?.aborted === true)
         return Promise.reject(new AnalysisCancelledError(OPERATION));
     return new Promise((resolve, reject) => {
         let settled = false;
         let timer;
+        const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+        const scheduleTimeout = () => {
+            if (deadline === undefined)
+                return;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                fail(new AnalysisTimeoutError(OPERATION, timeoutMs ?? 0));
+                return;
+            }
+            timer = setTimeout(scheduleTimeout, Math.min(remaining, 2_147_483_647));
+            timer.unref();
+        };
         const cleanup = () => {
             if (timer !== undefined)
                 clearTimeout(timer);
@@ -30,8 +42,7 @@ export const withPlaywrightExecutionBoundary = (work, maximumTimeoutMs, signal)
         const onAbort = () => {
             fail(new AnalysisCancelledError(OPERATION));
         };
-        timer = setTimeout(() => fail(new AnalysisTimeoutError(OPERATION, maximumTimeoutMs)), maximumTimeoutMs);
-        timer.unref();
+        scheduleTimeout();
         signal?.addEventListener("abort", onAbort, { once: true });
         if (signal?.aborted === true) {
             onAbort();

package/dist/browser/PlaywrightScenarioActions.js

@@ -14,15 +14,13 @@ const resolveLocator = (page, locator) => {
 const resolveValue = (value, secrets) => secrets.value(value);
 /** Execute one admitted declarative action with no caller-supplied code. */
 export const performPlaywrightScenarioAction = async (input) => {
-    const { page, action, secrets, defaultTimeoutMs, maximumTimeoutMs } = input;
+    const { page, action, secrets } = input;
     const timeout = "timeout_ms" in action ? action.timeout_ms : undefined;
-    const options = {
-        timeout: Math.min(timeout ?? defaultTimeoutMs, maximumTimeoutMs),
-    };
+    const options = timeout === undefined ? {} : { timeout };
     switch (action.action) {
         case "goto":
             await page.goto(secrets.url(action.destination), {
-                timeout: options.timeout,
+                ...options,
                 waitUntil: action.wait_until,
             });
             return;
@@ -55,8 +53,6 @@ export const performPlaywrightScenarioAction = async (input) => {
             });
             return;
         case "wait_for_timeout":
-            if (action.duration_ms > maximumTimeoutMs)
-                throw new Error("Scenario duration limit reached");
             await page.waitForTimeout(action.duration_ms);
     }
 };