rea-agents 3.1.0 → 3.2.1

package/dist/domain/electronActiveObservation.js

@@ -3,13 +3,11 @@ import { z } from "zod";
 const absolutePathSchema = z
     .string()
     .min(1)
-    .max(16_384)
     .refine(isAbsolute, "path must be absolute");
-const windowIndexSchema = z.number().int().min(0).max(99);
+const windowIndexSchema = z.number().int().min(0);
 const deepLinkUrlSchema = z
     .string()
     .min(1)
-    .max(4_096)
     .refine((value) => {
     try {
         return new URL(value).protocol.length > 0;
@@ -20,74 +18,45 @@ const deepLinkUrlSchema = z
 }, "deep-link url must be an absolute URL");
 const actionSchema = z.discriminatedUnion("kind", [
     z.strictObject({
-        step_id: z.string().min(1).max(128),
+        step_id: z.string().min(1),
         kind: z.literal("click"),
-        selector: z.string().min(1).max(512),
+        selector: z.string().min(1),
         window_index: windowIndexSchema.default(0),
     }),
     z.strictObject({
-        step_id: z.string().min(1).max(128),
+        step_id: z.string().min(1),
         kind: z.literal("wait"),
-        duration_ms: z.number().int().min(0).max(10_000),
+        duration_ms: z.number().int().min(0),
         window_index: windowIndexSchema.optional(),
     }),
     z.strictObject({
-        step_id: z.string().min(1).max(128),
+        step_id: z.string().min(1),
         kind: z.literal("renderer-reload"),
         window_index: windowIndexSchema.default(0),
     }),
     z.strictObject({
-        step_id: z.string().min(1).max(128),
+        step_id: z.string().min(1),
         kind: z.literal("renderer-crash"),
         window_index: windowIndexSchema.default(0),
     }),
     z.strictObject({
-        step_id: z.string().min(1).max(128),
+        step_id: z.string().min(1),
         kind: z.literal("deep-link"),
         delivery: z.enum(["open-url", "second-instance"]),
         url: deepLinkUrlSchema,
     }),
 ]);
-const limitsSchema = z.strictObject({
-    max_duration_ms: z.number().int().min(1).max(120_000).default(60_000),
-    action_timeout_ms: z.number().int().min(1).max(30_000).default(5_000),
-    max_actions: z.number().int().min(1).max(100).default(20),
-    max_ipc_events: z.number().int().min(1).max(10_000).default(2_000),
-    max_runtime_events: z.number().int().min(1).max(20_000).default(5_000),
-    max_processes: z.number().int().min(1).max(100).default(32),
-    max_windows: z.number().int().min(1).max(100).default(32),
-});
 /** Input for one explicit, provider-owned Electron runtime experiment. */
-export const electronActiveObservationInputSchema = z
-    .strictObject({
-    schema_version: z.literal(1),
+export const electronActiveObservationInputSchema = z.strictObject({
     executable_path: absolutePathSchema,
     application_path: absolutePathSchema,
     application_root: absolutePathSchema,
-    args: z.array(z.string().max(4_096)).max(32).default([]),
-    actions: z.array(actionSchema).max(100).default([]),
-    limits: limitsSchema.default({
-        max_duration_ms: 60_000,
-        action_timeout_ms: 5_000,
-        max_actions: 20,
-        max_ipc_events: 2_000,
-        max_runtime_events: 5_000,
-        max_processes: 32,
-        max_windows: 32,
-    }),
-    approved: z.literal(true),
-})
-    .superRefine((input, context) => {
-    if (input.actions.length > input.limits.max_actions)
-        context.addIssue({
-            code: "custom",
-            path: ["actions"],
-            message: "actions exceed the configured max_actions limit",
-        });
+    args: z.array(z.string()).default([]),
+    actions: z.array(actionSchema).default([]),
 });
 const ipcEventSchema = z.strictObject({
     sequence: z.number().int().min(1),
-    correlation_id: z.string().max(256).nullable().default(null),
+    correlation_id: z.string().nullable().default(null),
     kind: z.enum([
         "main-handler-invocation",
         "main-event-invocation",
@@ -99,13 +68,12 @@ const ipcEventSchema = z.strictObject({
         "ipc-renderer-invoke",
         "ipc-renderer-post-message",
     ]),
-    event: z.string().max(128).nullable().optional(),
+    event: z.string().nullable().optional(),
     phase: z
         .enum(["attempted", "completed", "blocked", "failed", "observed"])
         .nullable()
         .optional(),
-    channel: z.string().max(1_024).nullable(),
-    channel_truncated: z.boolean().default(false),
+    channel: z.string().nullable(),
     direction: z
         .enum([
         "renderer-to-main",
@@ -115,19 +83,18 @@ const ipcEventSchema = z.strictObject({
     ])
         .nullable()
         .optional(),
-    sender: z.string().max(256).nullable().optional(),
-    receiver: z.string().max(256).nullable().optional(),
-    frame: z.string().max(256).nullable().default(null),
-    target: z.string().max(256).nullable().optional(),
-    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).default("electron-active-hook"),
+    sender: z.string().nullable().optional(),
+    receiver: z.string().nullable().optional(),
+    frame: z.string().nullable().default(null),
+    target: z.string().nullable().optional(),
+    argument_shapes: z.array(z.string()),
+    result_shape: z.string().nullable(),
+    process_type: z.string().nullable(),
+    source: z.string().default("electron-active-hook"),
     capture_method: z
         .enum(["api-wrapper", "event-emitter", "process-hook"])
         .default("api-wrapper"),
-    artifact_path: z.string().max(16_384).nullable().default(null),
+    artifact_path: z.string().nullable().default(null),
     artifact_sha256: z
         .string()
         .regex(/^[a-f0-9]{64}$/u)
@@ -137,7 +104,7 @@ const ipcEventSchema = z.strictObject({
 });
 const timelineEventSchema = z.strictObject({
     sequence: z.number().int().min(1),
-    correlation_id: z.string().max(256).nullable().default(null),
+    correlation_id: z.string().nullable().default(null),
     kind: z.enum([
         "main-handler-invocation",
         "main-event-invocation",
@@ -163,10 +130,9 @@ const timelineEventSchema = 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(),
+    channel: z.string().nullable(),
     direction: z
         .enum([
         "renderer-to-main",
@@ -175,17 +141,16 @@ const timelineEventSchema = 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(),
-    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)
@@ -194,15 +159,15 @@ const timelineEventSchema = z.strictObject({
 });
 const processMetricSchema = 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 windowResultSchema = z.strictObject({
-    window_id: z.string().max(256),
-    web_contents_id: z.string().max(256),
-    url: z.string().max(65_536),
-    title: z.string().max(16_384),
+    window_id: z.string(),
+    web_contents_id: z.string(),
+    url: z.string(),
+    title: z.string(),
     visible: z.boolean().nullable(),
     destroyed: z.boolean(),
 });
@@ -210,18 +175,17 @@ const coverageSchema = z.strictObject({
     status: z.enum([
         "complete",
         "partial_attach",
-        "capture_truncated",
         "hook_conflict",
         "target_exited",
         "cleanup_failed",
     ]),
-    observed_event_families: z.array(z.string().max(128)).max(32),
-    unavailable_event_families: z.array(z.string().max(128)).max(32),
-    observed_roles: z.array(z.string().max(128)).max(16),
+    observed_event_families: z.array(z.string()),
+    unavailable_event_families: z.array(z.string()),
+    observed_roles: z.array(z.string()),
     pre_capture_activity: z.literal("unavailable"),
 });
-const actionResultSchema = z.strictObject({
-    step_id: z.string().min(1).max(128),
+const actionResultContextShape = {
+    step_id: z.string().min(1),
     kind: z.enum([
         "click",
         "wait",
@@ -230,42 +194,45 @@ const actionResultSchema = z.strictObject({
         "deep-link",
     ]),
     window_index: windowIndexSchema.nullable(),
-    target: z.string().max(256).nullable(),
-    status: z.enum(["completed", "failed", "cancelled"]),
+    target: z.string().nullable(),
     elapsed_ms: z.number().int().min(0),
-    error: z.string().nullable(),
-});
-/** Bounded result of a provider-owned Electron runtime experiment. */
+};
+const actionResultSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        ...actionResultContextShape,
+        status: z.literal("completed"),
+        error: z.null(),
+    }),
+    z.strictObject({
+        ...actionResultContextShape,
+        status: z.enum(["failed", "cancelled"]),
+        error: z.string(),
+    }),
+]);
+/** Result of a provider-owned Electron runtime experiment. */
 export const electronActiveObservationResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     application: z.strictObject({
         executable_path: absolutePathSchema,
         application_path: absolutePathSchema,
-        electron_version: z.string().min(1).max(256),
+        electron_version: z.string().min(1),
         process_ownership: z.literal("provider-owned"),
         cleanup: z.literal("terminated-owned-process"),
     }),
-    actions: z.array(actionResultSchema).max(100),
-    windows: z.array(windowResultSchema).max(100),
-    windows_truncated: z.boolean(),
+    actions: z.array(actionResultSchema),
+    windows: z.array(windowResultSchema),
     processes: z.strictObject({
-        items: z.array(processMetricSchema).max(100),
-        truncated: z.boolean(),
+        items: z.array(processMetricSchema),
     }),
     ipc: z.strictObject({
-        events: z.array(ipcEventSchema).max(10_000),
+        events: z.array(ipcEventSchema),
         observed: z.number().int().min(0),
-        retained: z.number().int().min(0),
-        truncated: z.boolean(),
     }),
     timeline: z
         .strictObject({
-        events: z.array(timelineEventSchema).max(20_000),
+        events: z.array(timelineEventSchema),
         observed: z.number().int().min(0),
-        retained: z.number().int().min(0),
-        truncated: z.boolean(),
     })
-        .default({ events: [], observed: 0, retained: 0, truncated: false }),
+        .default({ events: [], observed: 0 }),
     coverage: coverageSchema.default({
         status: "partial_attach",
         observed_event_families: [],
@@ -273,5 +240,5 @@ export const electronActiveObservationResultSchema = z.strictObject({
         observed_roles: [],
         pre_capture_activity: "unavailable",
     }),
-    limitations: z.array(z.string().max(4_096)).max(100),
+    limitations: z.array(z.string()),
 });

package/dist/domain/electronObservation.js

@@ -1,86 +1,30 @@
-import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserEndpointSchema } from "./browserObservation.js";
 import { webTextArtifactSchema } from "./webContentArtifact.js";
-/** Absolute operator-approved filesystem roots for Electron file pages. */
-export const electronFileRootsSchema = z
-    .array(z
-    .string()
-    .min(1)
-    .max(16_384)
-    .refine(isAbsolute, "Electron file roots must be absolute paths"))
-    .min(1)
-    .max(32)
-    .transform((roots) => [...new Set(roots)].sort());
 const approvedElectronInput = {
     cdp_endpoint: browserEndpointSchema,
-    allowed_file_roots: electronFileRootsSchema,
-    approved: z.literal(true),
 };
-/** Input for listing root-confined file:// page targets from Electron CDP. */
-export const listElectronTargetsInputSchema = z.object({
+/** Input for listing local file:// page targets from an explicit Electron CDP endpoint. */
+export const listElectronTargetsInputSchema = z.strictObject({
     ...approvedElectronInput,
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(200).default(100),
 });
 /** Input for passive structural inspection of one Electron file page. */
 const inspectElectronPageFacts = {
     ...approvedElectronInput,
-    target_id: z.string().trim().min(1).max(256),
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    limits: z
-        .object({
-        max_frames: z.number().int().min(1).max(1_000).default(200),
-        max_dom_nodes: z.number().int().min(1).max(10_000).default(2_000),
-        max_scripts: z.number().int().min(1).max(2_000).default(500),
-        max_resources: z.number().int().min(1).max(10_000).default(2_000),
-        max_workers: z.number().int().min(1).max(5_000).default(500),
-        max_script_source_bytes: z
-            .number()
-            .int()
-            .min(1)
-            .max(4 * 1_024 * 1_024)
-            .default(1_024 * 1_024),
-        max_total_script_source_bytes: z
-            .number()
-            .int()
-            .min(1)
-            .max(16 * 1_024 * 1_024)
-            .default(4 * 1_024 * 1_024),
-    })
-        .default({
-        max_frames: 200,
-        max_dom_nodes: 2_000,
-        max_scripts: 500,
-        max_resources: 2_000,
-        max_workers: 500,
-        max_script_source_bytes: 1_024 * 1_024,
-        max_total_script_source_bytes: 4 * 1_024 * 1_024,
-    }),
+    target_id: z.string().trim().min(1),
+    observation_ms: z.number().int().min(0).default(100),
 };
-export const inspectElectronPageInputSchema = z
-    .union([
-    z.object({
+export const inspectElectronPageInputSchema = z.union([
+    z.strictObject({
         ...inspectElectronPageFacts,
         include_script_sources: z.literal(false).default(false),
-        source_capture_approved: z.literal(false).default(false),
     }),
-    z.object({
+    z.strictObject({
         ...inspectElectronPageFacts,
         include_script_sources: z.literal(true),
-        source_capture_approved: z.literal(true),
     }),
-])
-    .superRefine((input, context) => {
-    if (input.limits.max_script_source_bytes >
-        input.limits.max_total_script_source_bytes)
-        context.addIssue({
-            code: "custom",
-            path: ["limits", "max_script_source_bytes"],
-            message: "Per-script source limit cannot exceed the total source limit",
-        });
-});
+]);
 const browserVersionSchema = z.object({
     product: z.string(),
     protocol_version: z.string(),
@@ -95,20 +39,11 @@ const electronTargetSchema = z.object({
     file_path: z.string(),
     attached: z.boolean(),
 });
-/** Root-filtered Electron file target inventory. */
+/** Complete local file target inventory from one Electron CDP endpoint. */
 export const electronTargetListSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
-    targets: z.object({
-        items: z.array(electronTargetSchema),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    }),
+    targets: z.array(electronTargetSchema),
     excluded: z.object({
-        outside_root: z.number().int().min(0),
         unsupported_url: z.number().int().min(0),
         non_page: z.number().int().min(0),
     }),
@@ -120,7 +55,6 @@ const electronSourceSchema = z.discriminatedUnion("included", [
 ]);
 /** Provider-neutral passive Electron file-page structure and script inventory. */
 export const electronPageInspectionSchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: electronTargetSchema,
     capture_window: z.object({
@@ -167,12 +101,12 @@ export const electronPageInspectionSchema = z.object({
     })),
     workers: z
         .array(z.object({
-        target_id: z.string().min(1).max(256),
-        type: z.string().min(1).max(100),
+        target_id: z.string().min(1),
+        type: z.string().min(1),
         file_path: z.string(),
         attached: z.boolean(),
-        opener_target_id: z.string().min(1).max(256).nullable(),
-        parent_frame_id: z.string().min(1).max(256).nullable(),
+        opener_target_id: z.string().min(1).nullable(),
+        parent_frame_id: z.string().min(1).nullable(),
     }))
         .default([]),
     limitations: z.array(z.string()),

package/dist/domain/electronStaticAnalysisBrowser.js

@@ -2,7 +2,6 @@ import * as t from "@babel/types";
 import { boundedExpression, collectContextBridgeMembers, electronStaticValue, objectProperty, } from "./electronStaticAnalysisValues.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
 import { argumentNode, calleeName, compareCodePoints, propertyName, range, staticPath, staticPathResolutionContext, } from "./javascriptStaticAnalysisHelpers.js";
-const MAX_WEB_PREFERENCES = 64;
 /** Inspect BrowserWindow, contextBridge, and utility-process syntax. */
 export const inspectElectronBrowserNode = (node, context) => {
     if (t.isNewExpression(node))
@@ -18,7 +17,7 @@ const inspectBrowserWindow = (node, context) => {
         return;
     const options = argumentNode(node.arguments[0]);
     const collected = collectWindowOptions(context.source, options);
-    accountForStructure(context, collected.unknown, collected.omitted);
+    context.accumulator.unknownFindings += collected.unknown;
     const finding = {
         options_status: options === undefined
             ? "missing"
@@ -27,9 +26,7 @@ const inspectBrowserWindow = (node, context) => {
                 : "dynamic",
         web_preferences_status: collected.status,
         web_preferences: collected.preferences,
-        omitted_web_preferences: collected.omitted,
-        preload_path: collected.preloadPath,
-        preload_resolution_context: collected.preloadResolutionContext,
+        ...collected.preload,
         module_key: null,
         location: range(node),
     };
@@ -45,37 +42,33 @@ const collectWindowOptions = (source, options) => {
         return {
             status: options === undefined ? "missing" : "dynamic",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: options === undefined ? 0 : 1,
-            omitted: 0,
         };
     const property = objectProperty(options, "webPreferences");
     if (property === undefined)
         return {
             status: "missing",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: 0,
-            omitted: 0,
         };
     if (!t.isObjectExpression(property.value))
         return {
             status: "dynamic",
             preferences: [],
-            preloadPath: null,
-            preloadResolutionContext: null,
+            preload: { preload_path: null, preload_resolution_context: null },
             unknown: 1,
-            omitted: 0,
         };
     return collectWebPreferences(source, property.value);
 };
 const collectWebPreferences = (source, object) => {
     const preferences = [];
     let unknown = 0;
-    let preloadPath = null;
-    let preloadResolutionContext = null;
+    let preload = {
+        preload_path: null,
+        preload_resolution_context: null,
+    };
     for (const property of object.properties) {
         if (t.isSpreadElement(property)) {
             unknown += 1;
@@ -103,10 +96,11 @@ const collectWebPreferences = (source, object) => {
             continue;
         }
         const path = name === "preload" ? staticPath(property.value) : undefined;
-        if (path !== undefined) {
-            preloadPath = path;
-            preloadResolutionContext = staticPathResolutionContext(property.value);
-        }
+        if (path !== undefined)
+            preload = {
+                preload_path: path,
+                preload_resolution_context: staticPathResolutionContext(property.value),
+            };
         const value = path === undefined
             ? electronStaticValue(source, property.value)
             : { status: "literal", value: path, expression: null };
@@ -117,11 +111,9 @@ const collectWebPreferences = (source, object) => {
     preferences.sort((left, right) => compareCodePoints(left.name, right.name));
     return {
         status: "object-literal",
-        preferences: preferences.slice(0, MAX_WEB_PREFERENCES),
-        preloadPath,
-        preloadResolutionContext,
+        preferences,
+        preload,
         unknown,
-        omitted: Math.max(0, preferences.length - MAX_WEB_PREFERENCES),
     };
 };
 const inspectContextBridge = (node, context) => {
@@ -142,18 +134,19 @@ const inspectContextBridge = (node, context) => {
     const unknown = (key.status === "dynamic" ? 1 : 0) +
         (worldId?.status === "dynamic" ? 1 : 0) +
         api.unknown;
-    accountForStructure(context, unknown, api.omitted);
+    context.accumulator.unknownFindings += unknown;
+    const apiKey = key.status === "dynamic"
+        ? { api_key: null, api_key_expression: key.expression }
+        : typeof key.value === "string"
+            ? { api_key: key.value, api_key_expression: null }
+            : { api_key: null, api_key_expression: null };
     const finding = {
+        ...apiKey,
         world: isolated ? "isolated" : "main",
         world_id: worldId,
-        api_key: key.status === "literal" && typeof key.value === "string"
-            ? key.value
-            : null,
-        api_key_expression: key.status === "dynamic" ? key.expression : null,
         api_status: api.status,
         members: api.members,
         unknown_members: api.unknown,
-        omitted_members: api.omitted,
         module_key: null,
         location: range(node),
     };
@@ -170,9 +163,6 @@ const inspectUtilityProcess = (node, context) => {
         return;
     const moduleNode = argumentNode(node.arguments[0]);
     const modulePath = moduleNode === undefined ? undefined : staticPath(moduleNode);
-    const moduleResolutionContext = modulePath === undefined || moduleNode === undefined
-        ? null
-        : staticPathResolutionContext(moduleNode);
     const options = argumentNode(node.arguments[2]);
     const serviceName = t.isObjectExpression(options) &&
         objectProperty(options, "serviceName") !== undefined
@@ -180,27 +170,27 @@ const inspectUtilityProcess = (node, context) => {
         : undefined;
     if (modulePath === undefined)
         context.accumulator.unknownFindings += 1;
+    const moduleReference = modulePath === undefined || moduleNode === undefined
+        ? {
+            module_path: null,
+            module_resolution_context: null,
+            module_expression: boundedExpression(context.source, moduleNode),
+        }
+        : {
+            module_path: modulePath,
+            module_resolution_context: staticPathResolutionContext(moduleNode),
+            module_expression: null,
+        };
     const finding = {
-        module_path: modulePath ?? null,
-        module_resolution_context: moduleResolutionContext,
-        module_expression: modulePath === undefined
-            ? boundedExpression(context.source, moduleNode)
-            : null,
+        ...moduleReference,
         service_name: serviceName ?? null,
         module_key: null,
         location: range(node),
     };
     addLocatedFinding(context, {
         collection: context.accumulator.utilityProcesses,
-        key: `electron-utility\0${modulePath ?? finding.module_expression ?? "[missing]"}`,
+        key: `electron-utility\0${finding.module_path ?? finding.module_expression}`,
         node,
         value: finding,
     });
 };
-const accountForStructure = (context, unknown, omitted) => {
-    context.accumulator.unknownFindings += unknown;
-    if (omitted === 0)
-        return;
-    context.accumulator.structuralTruncation = true;
-    context.accumulator.droppedFindings += omitted;
-};