425 lines
11 KiB
TypeScript
425 lines
11 KiB
TypeScript
import { z } from "zod";
|
|
|
|
import {
|
|
browserAllowedOriginsSchema,
|
|
browserEndpointSchema,
|
|
browserOriginSchema,
|
|
} from "./browserObservation.js";
|
|
|
|
export const BROWSER_SCENARIO_LIMITS = {
|
|
actions: 128,
|
|
secrets: 64,
|
|
storageEntries: 512,
|
|
replayRoutes: 256,
|
|
durationMs: 300_000,
|
|
actionTimeoutMs: 60_000,
|
|
} as const;
|
|
|
|
export const scenarioIdentifierSchema = z
|
|
.string()
|
|
.regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/u);
|
|
|
|
const absoluteExecutablePathSchema = z
|
|
.string()
|
|
.min(1)
|
|
.max(4_096)
|
|
.refine(
|
|
(value) =>
|
|
value.startsWith("/") ||
|
|
/^[A-Za-z]:[\\/]/u.test(value) ||
|
|
value.startsWith("\\\\"),
|
|
"Expected an absolute browser executable path",
|
|
);
|
|
|
|
const browserScenarioBaseUrlSchema = z
|
|
.string()
|
|
.min(1)
|
|
.max(65_536)
|
|
.transform((value, context) => {
|
|
let url: URL;
|
|
try {
|
|
url = new URL(value);
|
|
} catch {
|
|
context.addIssue({ code: "custom", message: "Invalid browser URL" });
|
|
return z.NEVER;
|
|
}
|
|
if (
|
|
(url.protocol !== "http:" && url.protocol !== "https:") ||
|
|
url.username !== "" ||
|
|
url.password !== "" ||
|
|
url.search !== "" ||
|
|
url.hash !== ""
|
|
) {
|
|
context.addIssue({
|
|
code: "custom",
|
|
message:
|
|
"Browser URLs must be HTTP(S), omit credentials, and declare query values separately",
|
|
});
|
|
return z.NEVER;
|
|
}
|
|
return url.toString();
|
|
});
|
|
|
|
export const browserScenarioValueSchema = z.discriminatedUnion("source", [
|
|
z.strictObject({
|
|
source: z.literal("literal"),
|
|
value: z.string().max(65_536),
|
|
classification: z.literal("public"),
|
|
}),
|
|
z.strictObject({
|
|
source: z.literal("secret"),
|
|
secret_id: scenarioIdentifierSchema,
|
|
}),
|
|
]);
|
|
export type BrowserScenarioValue = z.infer<typeof browserScenarioValueSchema>;
|
|
|
|
const queryEntrySchema = z.strictObject({
|
|
name: z.string().min(1).max(256),
|
|
value: browserScenarioValueSchema,
|
|
});
|
|
|
|
/** URL whose values remain explicit public literals or declared secret references. */
|
|
export const browserScenarioUrlSchema = z.strictObject({
|
|
url: browserScenarioBaseUrlSchema,
|
|
query: z.array(queryEntrySchema).max(64).default([]),
|
|
});
|
|
export type BrowserScenarioUrl = z.infer<typeof browserScenarioUrlSchema>;
|
|
|
|
export const browserScenarioBrowserSchema = z.discriminatedUnion("mode", [
|
|
z.strictObject({
|
|
mode: z.literal("launch"),
|
|
executable_path: absoluteExecutablePathSchema,
|
|
headless: z.literal(true),
|
|
user_data: z.literal("temporary-owned"),
|
|
cleanup: z.literal("close-and-delete-profile"),
|
|
}),
|
|
z.strictObject({
|
|
mode: z.literal("connect"),
|
|
cdp_endpoint: browserEndpointSchema,
|
|
target_id: z.string().trim().min(1).max(256),
|
|
ownership: z.literal("external"),
|
|
cleanup: z.literal("disconnect-only"),
|
|
}),
|
|
]);
|
|
|
|
export const browserScenarioEnvironmentSchema = z.strictObject({
|
|
viewport: z.strictObject({
|
|
width: z.number().int().min(320).max(7_680),
|
|
height: z.number().int().min(240).max(4_320),
|
|
device_scale_factor: z.number().min(0.5).max(4).default(1),
|
|
}),
|
|
locale: z
|
|
.string()
|
|
.min(2)
|
|
.max(64)
|
|
.regex(/^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/u),
|
|
timezone: z
|
|
.string()
|
|
.min(1)
|
|
.max(128)
|
|
.regex(/^[A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*$/u),
|
|
color_scheme: z.enum(["light", "dark", "no-preference"]),
|
|
reduced_motion: z.enum(["reduce", "no-preference"]),
|
|
service_workers: z.literal("block"),
|
|
});
|
|
|
|
const locatorSchema = z.discriminatedUnion("kind", [
|
|
z.strictObject({
|
|
kind: z.literal("test_id"),
|
|
value: z.string().min(1).max(512),
|
|
}),
|
|
z.strictObject({
|
|
kind: z.literal("role"),
|
|
role: z.enum([
|
|
"button",
|
|
"checkbox",
|
|
"combobox",
|
|
"dialog",
|
|
"link",
|
|
"listbox",
|
|
"menuitem",
|
|
"option",
|
|
"radio",
|
|
"slider",
|
|
"spinbutton",
|
|
"switch",
|
|
"tab",
|
|
"textbox",
|
|
]),
|
|
name: z.string().min(1).max(1_024),
|
|
exact: z.literal(true),
|
|
}),
|
|
z.strictObject({
|
|
kind: z.literal("css"),
|
|
selector: z.string().min(1).max(4_096),
|
|
approved: z.literal(true),
|
|
}),
|
|
]);
|
|
|
|
const stepBase = {
|
|
step_id: scenarioIdentifierSchema,
|
|
timeout_ms: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.max(BROWSER_SCENARIO_LIMITS.actionTimeoutMs)
|
|
.optional(),
|
|
};
|
|
|
|
export const browserScenarioActionSchema = z.discriminatedUnion("action", [
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.literal("goto"),
|
|
destination: browserScenarioUrlSchema,
|
|
wait_until: z.enum(["commit", "domcontentloaded", "load"]),
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
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),
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.literal("fill"),
|
|
locator: locatorSchema,
|
|
value: browserScenarioValueSchema,
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.literal("press"),
|
|
locator: locatorSchema,
|
|
key: z.string().min(1).max(64),
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.literal("select_option"),
|
|
locator: locatorSchema,
|
|
value: browserScenarioValueSchema,
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.enum(["check", "uncheck"]),
|
|
locator: locatorSchema,
|
|
}),
|
|
z.strictObject({
|
|
...stepBase,
|
|
action: z.literal("wait_for"),
|
|
locator: locatorSchema,
|
|
state: z.enum(["attached", "detached", "visible", "hidden"]),
|
|
}),
|
|
z.strictObject({
|
|
step_id: scenarioIdentifierSchema,
|
|
action: z.literal("wait_for_timeout"),
|
|
duration_ms: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.max(BROWSER_SCENARIO_LIMITS.actionTimeoutMs),
|
|
}),
|
|
]);
|
|
export type BrowserScenarioAction = z.infer<typeof browserScenarioActionSchema>;
|
|
|
|
const storageEntrySchema = z.strictObject({
|
|
name: z.string().min(1).max(1_024),
|
|
value: browserScenarioValueSchema,
|
|
});
|
|
|
|
export const browserScenarioStorageSchema = z.strictObject({
|
|
cookies: z
|
|
.array(
|
|
z.strictObject({
|
|
name: z.string().min(1).max(1_024),
|
|
value: browserScenarioValueSchema,
|
|
destination: browserScenarioUrlSchema,
|
|
http_only: z.boolean(),
|
|
secure: z.boolean(),
|
|
same_site: z.enum(["Strict", "Lax", "None"]),
|
|
}),
|
|
)
|
|
.max(128)
|
|
.default([]),
|
|
local_storage: z
|
|
.array(
|
|
z.strictObject({
|
|
origin: browserOriginSchema,
|
|
entries: z.array(storageEntrySchema).max(128),
|
|
}),
|
|
)
|
|
.max(32)
|
|
.default([]),
|
|
session_storage: z
|
|
.array(
|
|
z.strictObject({
|
|
origin: browserOriginSchema,
|
|
entries: z.array(storageEntrySchema).max(128),
|
|
}),
|
|
)
|
|
.max(32)
|
|
.default([]),
|
|
});
|
|
|
|
const headerNameSchema = z
|
|
.string()
|
|
.min(1)
|
|
.max(256)
|
|
.regex(/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u)
|
|
.transform((value) => value.toLowerCase());
|
|
|
|
const replayHeaderSchema = z.strictObject({
|
|
name: headerNameSchema,
|
|
value: browserScenarioValueSchema,
|
|
});
|
|
|
|
const replayResponseSchema = z.discriminatedUnion("kind", [
|
|
z.strictObject({
|
|
kind: z.literal("response"),
|
|
status: z.number().int().min(100).max(599),
|
|
headers: z.array(replayHeaderSchema).max(64).default([]),
|
|
body: browserScenarioValueSchema.optional(),
|
|
}),
|
|
z.strictObject({
|
|
kind: z.literal("redirect"),
|
|
status: z.union([
|
|
z.literal(301),
|
|
z.literal(302),
|
|
z.literal(303),
|
|
z.literal(307),
|
|
z.literal(308),
|
|
]),
|
|
destination: browserScenarioUrlSchema,
|
|
}),
|
|
]);
|
|
|
|
const replayRouteSchema = z.strictObject({
|
|
route_id: scenarioIdentifierSchema,
|
|
method: z.enum(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]),
|
|
request: browserScenarioUrlSchema,
|
|
response: replayResponseSchema,
|
|
});
|
|
|
|
export const browserScenarioRequestReplaySchema = z.discriminatedUnion("mode", [
|
|
z.strictObject({ mode: z.literal("disabled") }),
|
|
z.strictObject({
|
|
mode: z.literal("exact"),
|
|
unmatched: z.enum(["abort", "passthrough-approved-origins"]),
|
|
routes: z
|
|
.array(replayRouteSchema)
|
|
.min(1)
|
|
.max(BROWSER_SCENARIO_LIMITS.replayRoutes),
|
|
}),
|
|
]);
|
|
|
|
export const browserScenarioSecretSchema = z.strictObject({
|
|
secret_id: scenarioIdentifierSchema,
|
|
environment_variable: z.string().regex(/^[A-Z_][A-Z0-9_]{0,127}$/u),
|
|
purpose: z.enum(["input", "storage", "request-replay"]),
|
|
redaction: z.literal("replace-with-secret-reference"),
|
|
});
|
|
|
|
const REQUIRED_REDACTED_HEADERS = [
|
|
"authorization",
|
|
"cookie",
|
|
"proxy-authorization",
|
|
"set-cookie",
|
|
] as const;
|
|
|
|
const normalizedNames = (maximum: number) =>
|
|
z
|
|
.array(
|
|
z
|
|
.string()
|
|
.trim()
|
|
.min(1)
|
|
.max(256)
|
|
.transform((value) => value.toLowerCase()),
|
|
)
|
|
.max(maximum)
|
|
.transform((values) => [...new Set(values)].sort());
|
|
|
|
export const browserScenarioRedactionSchema = z
|
|
.strictObject({
|
|
secret_values: z.literal("replace-with-secret-reference"),
|
|
query_parameter_names: normalizedNames(128).default([]),
|
|
header_names: normalizedNames(128).default([...REQUIRED_REDACTED_HEADERS]),
|
|
})
|
|
.superRefine(({ header_names: names }, context) => {
|
|
for (const required of REQUIRED_REDACTED_HEADERS)
|
|
if (!names.includes(required))
|
|
context.addIssue({
|
|
code: "custom",
|
|
path: ["header_names"],
|
|
message: `Required credential header ${required} must be redacted`,
|
|
});
|
|
});
|
|
|
|
const snapshotKindSchema = z.enum([
|
|
"screenshot",
|
|
"dom",
|
|
"accessibility",
|
|
"url",
|
|
"history",
|
|
"storage",
|
|
]);
|
|
|
|
export const browserScenarioCaptureSchema = z.strictObject({
|
|
after_each_step: z.array(snapshotKindSchema).max(6),
|
|
at_end: z.array(snapshotKindSchema).max(6),
|
|
events: z.array(
|
|
z.enum([
|
|
"console",
|
|
"page-errors",
|
|
"network",
|
|
"websockets",
|
|
"frames",
|
|
"workers",
|
|
"popups",
|
|
"downloads",
|
|
]),
|
|
),
|
|
});
|
|
|
|
export const browserScenarioCaptureLimitsSchema = z.strictObject({
|
|
max_duration_ms: z
|
|
.number()
|
|
.int()
|
|
.min(100)
|
|
.max(BROWSER_SCENARIO_LIMITS.durationMs),
|
|
action_timeout_ms: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.max(BROWSER_SCENARIO_LIMITS.actionTimeoutMs),
|
|
navigation_timeout_ms: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.max(BROWSER_SCENARIO_LIMITS.actionTimeoutMs),
|
|
max_events: z.number().int().min(1).max(100_000),
|
|
max_frames: z.number().int().min(1).max(1_000),
|
|
max_workers: z.number().int().min(0).max(1_000),
|
|
max_popups: z.number().int().min(0).max(100),
|
|
max_websockets: z.number().int().min(0).max(10_000),
|
|
max_dom_nodes: z.number().int().min(1).max(100_000),
|
|
max_accessibility_nodes: z.number().int().min(1).max(100_000),
|
|
max_screenshots: z.number().int().min(0).max(256),
|
|
max_screenshot_bytes: z
|
|
.number()
|
|
.int()
|
|
.min(1)
|
|
.max(8 * 1_024 * 1_024),
|
|
max_storage_entries: z
|
|
.number()
|
|
.int()
|
|
.min(0)
|
|
.max(BROWSER_SCENARIO_LIMITS.storageEntries),
|
|
max_total_metadata_bytes: z
|
|
.number()
|
|
.int()
|
|
.min(1_024)
|
|
.max(64 * 1_024 * 1_024),
|
|
});
|
|
|
|
export const browserScenarioAllowedOriginsSchema = browserAllowedOriginsSchema;
|