Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

refactor(browser): remove arbitrary capture ceilings

morluto5dd3b4655e21
diff --git a/scripts/electron-active-hook.cjs b/scripts/electron-active-hook.cjs
index a8b0c6e38..4185ffc78 100644
--- a/scripts/electron-active-hook.cjs
+++ b/scripts/electron-active-hook.cjs
@@ -4,8 +4,6 @@ const {
createElectronActiveBoundaryPatches,
} = require("./electron-active-hook-boundaries.cjs");
-const MAX_EVENT_NAME_LENGTH = 128;
-const MAX_IDENTIFIER_LENGTH = 256;
const ipcEventKinds = new Set([
"main-handler-invocation",
"main-event-invocation",
@@ -24,9 +22,6 @@ let observedRuntime = 0;
let sequence = 0;
let correlationSequence = 0;
-const boundedString = (value, maximum) =>
- typeof value === "string" ? value.slice(0, maximum) : null;
-
const shape = (value, depth = 0) => {
if (depth > 2 || value === null) return value === null ? "null" : "nested";
if (Array.isArray(value)) return "array";
@@ -64,7 +59,7 @@ const isAllowedNavigation = (value) => {
const processType = () =>
typeof process.type === "string" && process.type.length > 0
- ? process.type.slice(0, MAX_IDENTIFIER_LENGTH)
+ ? process.type
: "main";
const identity = (value, prefix) => {
@@ -72,9 +67,9 @@ const identity = (value, prefix) => {
const id = value.id;
const processId = value.pid;
return typeof id === "string" || typeof id === "number"
- ? `${prefix}:${String(id)}`.slice(0, MAX_IDENTIFIER_LENGTH)
+ ? `${prefix}:${String(id)}`
: typeof processId === "number"
- ? `${prefix}:pid:${String(processId)}`.slice(0, MAX_IDENTIFIER_LENGTH)
+ ? `${prefix}:pid:${String(processId)}`
: null;
};
@@ -82,7 +77,7 @@ const frameIdentity = (event) => {
const frame = event?.senderFrame ?? event?.frame;
const id = frame?.frameTreeNodeId ?? frame?.routingId ?? frame?.id;
return typeof id === "string" || typeof id === "number"
- ? `frame:${String(id)}`.slice(0, MAX_IDENTIFIER_LENGTH)
+ ? `frame:${String(id)}`
: null;
};
@@ -119,20 +114,24 @@ const record = (event) => {
: [];
events.push({
...raw,
- correlation_id: boundedString(raw.correlation_id, MAX_IDENTIFIER_LENGTH),
- event: boundedString(raw.event, MAX_EVENT_NAME_LENGTH),
+ correlation_id: raw.correlation_id,
+ event: typeof raw.event === "string" ? raw.event : null,
channel: typeof raw.channel === "string" ? raw.channel : null,
- sender: boundedString(raw.sender, MAX_IDENTIFIER_LENGTH),
- receiver: boundedString(raw.receiver, MAX_IDENTIFIER_LENGTH),
- frame: boundedString(raw.frame, MAX_IDENTIFIER_LENGTH),
- target: boundedString(raw.target, MAX_IDENTIFIER_LENGTH),
- argument_shapes: argumentShapes.map(
- (value) => boundedString(value, 64) ?? "unknown",
+ sender: typeof raw.sender === "string" ? raw.sender : null,
+ receiver: typeof raw.receiver === "string" ? raw.receiver : null,
+ frame: typeof raw.frame === "string" ? raw.frame : null,
+ target: typeof raw.target === "string" ? raw.target : null,
+ argument_shapes: argumentShapes.map((value) =>
+ typeof value === "string" ? value : "unknown",
),
- result_shape: boundedString(raw.result_shape, 64),
- process_type: boundedString(raw.process_type, MAX_IDENTIFIER_LENGTH),
- artifact_path: boundedString(raw.artifact_path, 16_384),
- artifact_sha256: boundedString(raw.artifact_sha256, 64),
+ result_shape:
+ typeof raw.result_shape === "string" ? raw.result_shape : null,
+ process_type:
+ typeof raw.process_type === "string" ? raw.process_type : null,
+ artifact_path:
+ typeof raw.artifact_path === "string" ? raw.artifact_path : null,
+ artifact_sha256:
+ typeof raw.artifact_sha256 === "string" ? raw.artifact_sha256 : null,
});
return events.at(-1);
};
diff --git a/src/browser/CdpCaptureValues.ts b/src/browser/CdpCaptureValues.ts
index fce0b4a77..3d0e7c5d2 100644
--- a/src/browser/CdpCaptureValues.ts
+++ b/src/browser/CdpCaptureValues.ts
@@ -35,11 +35,6 @@ export const requiredRecord = (value: unknown): UnknownRecord => {
return record;
};
-export const boundedText = (value: unknown, maximum = 1_024): string | null => {
- const text = stringValue(value);
- return text === undefined ? null : text.slice(0, maximum);
-};
-
export const isHttpUrl = (value: string | undefined): boolean => {
if (value === undefined) return false;
try {
diff --git a/src/browser/ElectronFileScope.ts b/src/browser/ElectronFileScope.ts
index 9c80afd49..d87138e53 100644
--- a/src/browser/ElectronFileScope.ts
+++ b/src/browser/ElectronFileScope.ts
@@ -17,7 +17,7 @@ export const authorizedElectronFile = async (
value: string,
roots: readonly string[],
): Promise<string | undefined> => {
- if (value.length > 65_536 || /%(?:2f|5c)/iu.test(value)) return undefined;
+ if (/%(?:2f|5c)/iu.test(value)) return undefined;
let url: URL;
try {
url = new URL(value);
diff --git a/src/browser/PlaywrightElectronActiveActions.test.ts b/src/browser/PlaywrightElectronActiveActions.test.ts
index f0e717189..2ddee2a80 100644
--- a/src/browser/PlaywrightElectronActiveActions.test.ts
+++ b/src/browser/PlaywrightElectronActiveActions.test.ts
@@ -7,7 +7,7 @@ import {
import { createElectronActiveObservationFixtureResult } from "../domain/electronActiveObservation.fixture.js";
import { runElectronActions } from "./PlaywrightElectronActiveActions.js";
-it("parses bounded window, renderer, and deep-link actions for agents", () => {
+it("parses window, renderer, and deep-link actions for agents", () => {
const input = electronActiveObservationInputSchema.parse({
executable_path: "/opt/electron",
application_path: "/opt/app/main.js",
@@ -122,12 +122,7 @@ it("redacts action inputs from Playwright failures", async () => {
windows: () => [page],
};
- const result = await runElectronActions(
- application as never,
- input,
- {},
- Date.now() + 1_000,
- );
+ const result = await runElectronActions(application as never, input, {});
expect(result[0]).toMatchObject({
status: "failed",
@@ -154,7 +149,6 @@ it("retains complete action errors and Electron window text", async () => {
{ windows: () => [page] } as never,
input,
{},
- Date.now() + 1_000,
);
const result = createElectronActiveObservationFixtureResult("/opt/app");
const longUrl = `file://${"/segment".repeat(10_000)}`;
@@ -281,12 +275,7 @@ it("runs an untargeted deep-link without requiring a BrowserWindow", async () =>
evaluate: async () => true,
};
- const result = await runElectronActions(
- application as never,
- input,
- {},
- Date.now() + 1_000,
- );
+ const result = await runElectronActions(application as never, input, {});
expect(result).toMatchObject([
{
@@ -297,6 +286,30 @@ it("runs an untargeted deep-link without requiring a BrowserWindow", async () =>
]);
});
+it("honors caller-selected Electron waits beyond the former action timeout", async () => {
+ const input = electronActiveObservationInputSchema.parse({
+ executable_path: "/opt/electron",
+ application_path: "/opt/app/main.js",
+ application_root: "/opt/app",
+ actions: [{ step_id: "wait-long", kind: "wait", duration_ms: 60_000 }],
+ });
+ let duration = 0;
+ const page = {
+ waitForTimeout: async (value: number) => {
+ duration = value;
+ },
+ };
+ const application = {
+ windows: () => [page],
+ firstWindow: async () => page,
+ };
+
+ const result = await runElectronActions(application as never, input, {});
+
+ expect(result[0]).toMatchObject({ status: "completed" });
+ expect(duration).toBe(60_000);
+});
+
it("rejects action outcomes that disagree with their error state", () => {
const result = createElectronActiveObservationFixtureResult("/opt/app");
const action = result.actions[0];
diff --git a/src/browser/PlaywrightElectronActiveActions.ts b/src/browser/PlaywrightElectronActiveActions.ts
index f8b7bcd85..8ec8262e6 100644
--- a/src/browser/PlaywrightElectronActiveActions.ts
+++ b/src/browser/PlaywrightElectronActiveActions.ts
@@ -10,7 +10,6 @@ import type {
} from "../domain/electronActiveObservation.js";
const OPERATION = "capture_electron_scenario" as const;
-const ACTION_TIMEOUT_MS = 5_000;
const hookEventSchema = z.strictObject({
sequence: z.number().int().min(1),
@@ -108,7 +107,6 @@ export const runElectronActions = async (
application: ElectronApplication,
input: ElectronActiveObservationInput,
options: ExecutionOptions,
- deadline: number,
): Promise<ElectronActions> => {
const actions: ElectronActions = [];
for (const action of input.actions) {
@@ -118,18 +116,13 @@ export const runElectronActions = async (
const windowIndex = actionWindowIndex(action);
let selectedWindow: Page | undefined;
try {
- const remaining = deadline - Date.now();
- if (remaining <= 0)
- throw new BrowserObservationError(OPERATION, "timeout");
selectedWindow =
windowIndex === null
? undefined
: await waitForWindow({
application,
windowIndex,
- timeout: ACTION_TIMEOUT_MS,
signal: options.signal,
- deadline,
});
if (
(action.kind === "click" ||
@@ -143,10 +136,7 @@ export const runElectronActions = async (
application,
action,
selectedWindow,
- remaining,
- actionTimeoutMs: ACTION_TIMEOUT_MS,
options,
- deadline,
});
actions.push({
step_id: action.step_id,
@@ -179,20 +169,14 @@ type RunActionContext = {
readonly application: ElectronApplication;
readonly action: ElectronAction;
readonly selectedWindow: Page | undefined;
- readonly remaining: number;
- readonly actionTimeoutMs: number;
readonly options: ExecutionOptions;
- readonly deadline: number;
};
const runAction = async ({
application,
action,
selectedWindow,
- remaining,
- actionTimeoutMs,
options,
- deadline,
}: RunActionContext): Promise<void> => {
switch (action.kind) {
case "click":
@@ -200,25 +184,21 @@ const runAction = async ({
throw new BrowserObservationError(OPERATION, "window_not_found");
await runWithExecutionLimits(
selectedWindow.locator(action.selector).click({
- timeout: Math.min(actionTimeoutMs, remaining),
+ timeout: 0,
}),
options.signal,
- deadline,
);
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)),
+ page.waitForTimeout(action.duration_ms),
options.signal,
- deadline,
);
- if (action.duration_ms > remaining)
- throw new BrowserObservationError(OPERATION, "timeout");
return;
}
case "renderer-reload":
@@ -226,10 +206,9 @@ const runAction = async ({
throw new BrowserObservationError(OPERATION, "window_not_found");
await runWithExecutionLimits(
selectedWindow.reload({
- timeout: Math.min(actionTimeoutMs, remaining),
+ timeout: 0,
}),
options.signal,
- deadline,
);
return;
case "renderer-crash": {
@@ -241,7 +220,6 @@ const runAction = async ({
return true;
}, action.window_index),
options.signal,
- deadline,
);
if (!crashed)
throw new BrowserObservationError(OPERATION, "window_not_found");
@@ -251,7 +229,6 @@ const runAction = async ({
await runWithExecutionLimits(
emitDeepLink(application, action),
options.signal,
- deadline,
);
return;
}
@@ -273,20 +250,15 @@ const actionWindowIndex = (action: ElectronAction): number | null => {
type WaitForWindowContext = {
readonly application: ElectronApplication;
readonly windowIndex: number;
- readonly timeout: number;
readonly signal: AbortSignal | undefined;
- readonly deadline: number;
};
const waitForWindow = async ({
application,
windowIndex,
- timeout,
signal,
- deadline,
}: WaitForWindowContext): Promise<Page> => {
- const stopAt = Math.min(deadline, Date.now() + timeout);
- while (Date.now() < stopAt) {
+ while (true) {
if (signal?.aborted === true)
throw new BrowserObservationError(OPERATION, "cancelled");
const window = application.windows()[windowIndex];
@@ -294,10 +266,8 @@ const waitForWindow = async ({
await runWithExecutionLimits(
new Promise<void>((resolve) => setTimeout(resolve, 25)),
signal,
- stopAt,
);
}
- throw new BrowserObservationError(OPERATION, "window_not_found");
};
const emitDeepLink = (
@@ -430,35 +400,39 @@ export const readApplicationState = async (
};
};
-/** 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 <Value>(
operation: Promise<Value>,
signal: AbortSignal | undefined,
- deadline: number,
+ deadline?: number,
): Promise<Value> => {
if (signal?.aborted === true)
throw new BrowserObservationError(OPERATION, "cancelled");
+ if (signal === undefined && deadline === undefined) return operation;
let timer: ReturnType<typeof setTimeout> | undefined;
let abortListener: (() => void) | undefined;
- const timeout = new Promise<never>((_, reject) => {
- timer = setTimeout(
- () => reject(new BrowserObservationError(OPERATION, "timeout")),
- Math.max(1, deadline - Date.now()),
+ const interruptions: Promise<never>[] = [];
+ if (deadline !== undefined)
+ interruptions.push(
+ new Promise<never>((_, reject) => {
+ timer = setTimeout(
+ () => reject(new BrowserObservationError(OPERATION, "timeout")),
+ Math.max(1, deadline - Date.now()),
+ );
+ }),
+ );
+ if (signal !== undefined)
+ interruptions.push(
+ new Promise<never>((_, reject) => {
+ abortListener = () =>
+ reject(new BrowserObservationError(OPERATION, "cancelled"));
+ signal.addEventListener("abort", abortListener, { once: true });
+ }),
);
- });
- const cancellation =
- signal === undefined
- ? timeout
- : Promise.race([
- timeout,
- new Promise<never>((_, 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) clearTimeout(timer);
if (abortListener !== undefined)
diff --git a/src/browser/PlaywrightElectronActiveProvider.ts b/src/browser/PlaywrightElectronActiveProvider.ts
index c4ba199f4..110314a0a 100644
--- a/src/browser/PlaywrightElectronActiveProvider.ts
+++ b/src/browser/PlaywrightElectronActiveProvider.ts
@@ -41,7 +41,7 @@ import {
} from "./PlaywrightElectronActiveActions.js";
const OPERATION = "capture_electron_scenario" as const;
-const RUN_TIMEOUT_MS = 60_000;
+const STARTUP_TIMEOUT_MS = 60_000;
/** Public identity for provider-owned Electron runtime experiments. */
export const PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY: ProviderIdentity =
@@ -165,14 +165,14 @@ export class PlaywrightElectronActiveProvider
try {
if (options.signal?.aborted === true)
throw new BrowserObservationError(OPERATION, "cancelled");
- const deadline = Date.now() + RUN_TIMEOUT_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(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 (
@@ -192,16 +192,10 @@ export class PlaywrightElectronActiveProvider
expectedCommand: paths.executable,
sweepTokenOwnedProcesses: true,
};
- const actions = await runElectronActions(
- application,
- input,
- options,
- deadline,
- );
+ const actions = await runElectronActions(application, input, options);
const state = await runWithExecutionLimits(
readApplicationState(application),
options.signal,
- deadline,
);
outcome = ok(createResult(paths, input, actions, state));
} catch (cause: unknown) {
@@ -341,7 +335,7 @@ const createResult = (
},
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 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.",
diff --git a/src/domain/browserScenario.test.ts b/src/domain/browserScenario.test.ts
index 757b8ed05..3eaa90d4e 100644
--- a/src/domain/browserScenario.test.ts
+++ b/src/domain/browserScenario.test.ts
@@ -165,3 +165,36 @@ it("accepts complete browser inputs beyond former string length caps", () => {
: undefined,
).toBe(longToken);
});
+
+it("accepts caller-selected viewport sizes and click counts without ceilings", () => {
+ const input = {
+ browser: {
+ mode: "launch",
+ executable_path: "/opt/chromium",
+ headless: true,
+ user_data: "temporary-owned",
+ cleanup: "close-and-delete-profile",
+ },
+ start_url: { url: "https://app.example.test/" },
+ allowed_origins: ["https://app.example.test"],
+ environment: {
+ viewport: { width: 20_000, height: 10_000, device_scale_factor: 8 },
+ },
+ actions: [
+ {
+ step_id: "many-clicks",
+ action: "click",
+ locator: { kind: "css", selector: "#item" },
+ click_count: 4,
+ },
+ ],
+ };
+
+ const parsed = browserScenarioSchema.parse(input);
+ expect(parsed.environment.viewport).toEqual({
+ width: 20_000,
+ height: 10_000,
+ device_scale_factor: 8,
+ });
+ expect(parsed.actions[0]).toMatchObject({ click_count: 4 });
+});
diff --git a/src/domain/browserScenarioCapture.test.ts b/src/domain/browserScenarioCapture.test.ts
index 034343919..2de0b0bdc 100644
--- a/src/domain/browserScenarioCapture.test.ts
+++ b/src/domain/browserScenarioCapture.test.ts
@@ -8,6 +8,7 @@ import {
browserScenarioEventSchema,
browserStepArtifactsSchema,
} from "./browserScenarioCaptureValues.js";
+import { browserScenarioCaptureSchema } from "./browserScenarioCapture.js";
const networkEvent = {
sequence: 1,
@@ -140,6 +141,69 @@ it("accepts complete storage, history, and text artifacts beyond former caps", (
expect(parsed.success).toBe(true);
});
+it("accepts complete scenario output beyond former string and origin caps", () => {
+ const longText = "detail".repeat(1_000);
+ const origins = Array.from(
+ { length: 33 },
+ (_, index) => `https://site-${index}.example.test`,
+ );
+ const step = (index: number) => ({
+ step_index: index,
+ step_id: longText,
+ action: longText,
+ elapsed_ms: 0,
+ before_url: sanitizeBrowserUrl("https://example.test/"),
+ after_url: sanitizeBrowserUrl("https://example.test/"),
+ event_sequence_start: 1,
+ event_sequence_end: 0,
+ artifacts: {
+ screenshot: { state: "not_requested" },
+ dom: { state: "not_requested" },
+ accessibility: { state: "not_requested" },
+ url: { state: "not_requested" },
+ history: { state: "not_requested" },
+ storage: { state: "not_requested" },
+ },
+ completeness: {
+ status: "complete",
+ equality_eligible: true,
+ missing_sections: [],
+ truncated_sections: [],
+ },
+ status: "completed",
+ error: null,
+ });
+ const parsed = browserScenarioCaptureSchema.parse({
+ browser: {
+ mode: "launch",
+ process_ownership: "provider-owned",
+ cleanup: "terminated-owned-process",
+ product: longText,
+ version: longText,
+ },
+ scenario: {
+ start_origin: longText,
+ allowed_origins: origins,
+ action_count: 1,
+ secret_references: [longText],
+ },
+ duration_ms: 0,
+ steps: [step(0), step(1)],
+ events: { retained: 0, dropped: 0, items: [] },
+ completeness: {
+ status: "complete",
+ equality_eligible: true,
+ missing_sections: [],
+ truncated_sections: [],
+ },
+ limitations: Array.from({ length: 65 }, () => longText),
+ });
+
+ expect(parsed.scenario.allowed_origins).toHaveLength(33);
+ expect(parsed.steps[0]?.step_id).toBe(longText);
+ expect(parsed.limitations).toHaveLength(65);
+});
+
it("derives equality eligibility from exact completeness state", () => {
expect(
browserScenarioCompletenessSchema.safeParse({
diff --git a/src/domain/browserScenarioCapture.ts b/src/domain/browserScenarioCapture.ts
index 3ae14dad0..5f2c261fb 100644
--- a/src/domain/browserScenarioCapture.ts
+++ b/src/domain/browserScenarioCapture.ts
@@ -21,21 +21,21 @@ export {
type BrowserStepArtifacts,
} from "./browserScenarioCaptureValues.js";
-/** Step-indexed, explicitly bounded browser scenario observation. */
+/** Step-indexed browser scenario observation. */
export const browserScenarioCaptureSchema = z
.strictObject({
browser: z.strictObject({
mode: z.enum(["launch", "connect"]),
process_ownership: z.enum(["provider-owned", "external"]),
cleanup: z.enum(["terminated-owned-process", "disconnected-external"]),
- product: z.string().min(1).max(1_024),
- version: z.string().min(1).max(256),
+ product: z.string().min(1),
+ version: z.string().min(1),
}),
scenario: z.strictObject({
- start_origin: z.string().min(1).max(2_048),
- allowed_origins: z.array(z.string().min(1).max(2_048)).min(1).max(32),
+ start_origin: z.string().min(1),
+ allowed_origins: z.array(z.string().min(1)).min(1),
action_count: z.number().int().min(1),
- secret_references: z.array(z.string().min(1).max(64)),
+ secret_references: z.array(z.string().min(1)),
}),
duration_ms: z.number().int().min(0),
steps: z.array(browserScenarioStepSchema).min(1),
@@ -45,7 +45,7 @@ export const browserScenarioCaptureSchema = z
items: z.array(browserScenarioEventSchema),
}),
completeness: browserScenarioCompletenessSchema,
- limitations: z.array(z.string().min(1).max(2_048)).max(64),
+ limitations: z.array(z.string().min(1)),
})
.superRefine((capture, context) => {
if (capture.events.retained !== capture.events.items.length)
diff --git a/src/domain/browserScenarioCaptureValues.ts b/src/domain/browserScenarioCaptureValues.ts
index 5b12b5400..cf4fcdf48 100644
--- a/src/domain/browserScenarioCaptureValues.ts
+++ b/src/domain/browserScenarioCaptureValues.ts
@@ -30,13 +30,13 @@ export const captureStateSchema = <Schema extends z.ZodType>(value: Schema) =>
}),
z.strictObject({
state: z.literal("missing"),
- reason: z.string().min(1).max(1_024),
+ reason: z.string().min(1),
}),
z.strictObject({
state: z.literal("truncated"),
observed: z.number().int().min(0),
retained: z.number().int().min(0),
- reason: z.string().min(1).max(1_024),
+ reason: z.string().min(1),
}),
]);
@@ -281,8 +281,8 @@ export const classifyBrowserScenarioCompleteness = (
const browserScenarioStepShape = {
step_index: z.number().int().min(0),
- step_id: z.string().min(1).max(64),
- action: z.string().min(1).max(64),
+ step_id: z.string().min(1),
+ action: z.string().min(1),
elapsed_ms: z.number().int().min(0),
before_url: sanitizedBrowserUrlSchema,
after_url: sanitizedBrowserUrlSchema,
diff --git a/src/domain/browserScenarioValues.ts b/src/domain/browserScenarioValues.ts
index 7806dd6aa..2895bb41e 100644
--- a/src/domain/browserScenarioValues.ts
+++ b/src/domain/browserScenarioValues.ts
@@ -95,9 +95,9 @@ export const browserScenarioEnvironmentSchema = z
.strictObject({
viewport: z
.strictObject({
- width: z.number().int().min(320).max(7_680).default(1_280),
- height: z.number().int().min(240).max(4_320).default(720),
- device_scale_factor: z.number().min(0.5).max(4).default(1),
+ width: z.number().int().positive().default(1_280),
+ height: z.number().int().positive().default(720),
+ device_scale_factor: z.number().positive().default(1),
})
.default({ width: 1_280, height: 720, device_scale_factor: 1 }),
locale: z
@@ -182,7 +182,7 @@ export const browserScenarioActionSchema = z.discriminatedUnion("action", [
action: z.literal("click"),
locator: locatorSchema,
button: z.enum(["left", "middle", "right"]).default("left"),
- click_count: z.number().int().min(1).max(3).default(1),
+ click_count: z.number().int().positive().default(1),
}),
z.strictObject({
...stepBase,
@@ -382,8 +382,8 @@ const snapshotKindSchema = z.enum([
export const browserScenarioCaptureSchema = z
.strictObject({
- after_each_step: z.array(snapshotKindSchema).max(6).default([]),
- at_end: z.array(snapshotKindSchema).max(6).default(["url"]),
+ after_each_step: z.array(snapshotKindSchema).default([]),
+ at_end: z.array(snapshotKindSchema).default(["url"]),
events: z
.array(
z.enum([
diff --git a/src/domain/electronActiveObservation.fixture.ts b/src/domain/electronActiveObservation.fixture.ts
index d38edbac5..144dccca8 100644
--- a/src/domain/electronActiveObservation.fixture.ts
+++ b/src/domain/electronActiveObservation.fixture.ts
@@ -51,6 +51,6 @@ export const createElectronActiveObservationFixtureResult = (
observed: 1,
},
limitations: [
- "IPC payloads are represented only by bounded value shapes; values are never retained.",
+ "IPC payloads are represented by value shapes; payload values are never retained.",
],
});
diff --git a/src/domain/webScreenshot.test.ts b/src/domain/webScreenshot.test.ts
index 82fb8d42b..60f4ebd37 100644
--- a/src/domain/webScreenshot.test.ts
+++ b/src/domain/webScreenshot.test.ts
@@ -35,4 +35,15 @@ describe("inline web screenshots", () => {
}).success,
).toBe(false);
});
+
+ it("accepts a caller-supplied target ID without a length ceiling", () => {
+ const targetId = "target-".repeat(100);
+ expect(
+ captureWebScreenshotInputSchema.parse({
+ cdp_endpoint: "http://127.0.0.1:9222",
+ allowed_origins: ["https://app.example.test"],
+ target_id: targetId,
+ }).target_id,
+ ).toBe(targetId);
+ });
});
diff --git a/src/domain/webScreenshot.ts b/src/domain/webScreenshot.ts
index 536541bc1..f319e6c61 100644
--- a/src/domain/webScreenshot.ts
+++ b/src/domain/webScreenshot.ts
@@ -35,7 +35,7 @@ export type WebScreenshotArtifact = z.infer<typeof webScreenshotArtifactSchema>;
export const captureWebScreenshotInputSchema = z.strictObject({
cdp_endpoint: browserEndpointSchema,
allowed_origins: browserAllowedOriginsSchema,
- target_id: z.string().trim().min(1).max(256),
+ target_id: z.string().trim().min(1),
});
export type CaptureWebScreenshotInput = z.infer<
typeof captureWebScreenshotInputSchema
diff --git a/tests/boundary/browser/electronActiveHook.test.ts b/tests/boundary/browser/electronActiveHook.test.ts
index 7ad2c4d33..75ad44f83 100644
--- a/tests/boundary/browser/electronActiveHook.test.ts
+++ b/tests/boundary/browser/electronActiveHook.test.ts
@@ -87,6 +87,8 @@ electron.ipcMain.handle(channel, async () => ({ ok: true }));
await electron.ipcMain.handlers.get(channel)({ sender: { id: 9 }, senderFrame: { routingId: 7 } }, ...Array.from({ length: 40 }, () => ({ value: true })));
window.webContents.send("main-to-renderer", { value: true });
window.webContents.emit("render-process-gone", { reason: "crashed" });
+const longEventName = "l".repeat(2048);
+window.webContents.emit(longEventName);
const utility = electron.utilityProcess.fork("utility.js");
utility.emit("message", { data: { value: true } });
utility.postMessage({ value: true });
@@ -163,6 +165,14 @@ it("retains active hook lifecycle and IPC evidence without a count ceiling", asy
});
expect(ipc?.channel).toBe("x".repeat(2_048));
expect(ipc?.argument_shapes).toHaveLength(40);
+ expect(snapshot.events).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ kind: "web-contents-lifecycle",
+ event: "l".repeat(2048),
+ }),
+ ]),
+ );
});
it("preserves fatal process termination after recording uncaught exceptions", async () => {
diff --git a/tests/boundary/filesystem/electronFileScope.test.ts b/tests/boundary/filesystem/electronFileScope.test.ts
index 9dbc7b7b5..68bf6f388 100644
--- a/tests/boundary/filesystem/electronFileScope.test.ts
+++ b/tests/boundary/filesystem/electronFileScope.test.ts
@@ -56,4 +56,14 @@ describe("Electron file scope", () => {
await authorizedElectronFile("file:///tmp/root%2Findex.html", roots),
).toBeUndefined();
});
+
+ it("accepts file URLs with long query text inside a root", async () => {
+ const root = await createTestTempDirectory("rea-electron-long-url-");
+ const path = join(root, "index.html");
+ await writeFile(path, "allowed");
+ const roots = await canonicalElectronRoots([root]);
+ const value = `${pathToFileURL(path).href}?${"x".repeat(70_000)}`;
+
+ await expect(authorizedElectronFile(value, roots)).resolves.toBe(path);
+ });
});