@dyyz1993/agent-browser 0.9.2

package/dist/protocol.js

@@ -0,0 +1,912 @@
+import { z } from 'zod';
+// Base schema for all commands
+const baseCommandSchema = z.object({
+    id: z.string(),
+    action: z.string(),
+});
+// Human config schema for human-like mouse movement (set via AGENT_BROWSER_HUMAN env)
+const humanConfigSchema = z.object({
+    enabled: z.boolean(),
+    pathType: z.enum(['bezier', 'arc', 'random', 'linear']),
+});
+// Helper to add inFrame support to element-action schemas
+const withFrame = (schema) => schema.extend({ inFrame: z.string().optional() });
+// Individual action schemas
+const launchSchema = baseCommandSchema.extend({
+    action: z.literal('launch'),
+    headless: z.boolean().optional(),
+    viewport: z
+        .object({
+        width: z.number().positive(),
+        height: z.number().positive(),
+    })
+        .optional(),
+    browser: z.enum(['chromium', 'firefox', 'webkit']).optional(),
+    cdpPort: z.number().positive().optional(),
+    cdpUrl: z
+        .string()
+        .url()
+        .refine((url) => url.startsWith('ws://') ||
+        url.startsWith('wss://') ||
+        url.startsWith('http://') ||
+        url.startsWith('https://'), { message: 'CDP URL must start with ws://, wss://, http://, or https://' })
+        .optional(),
+    executablePath: z.string().optional(),
+    extensions: z.array(z.string()).optional(),
+    headers: z.record(z.string()).optional(),
+    proxy: z
+        .object({
+        server: z.string().min(1),
+        bypass: z.string().optional(),
+        username: z.string().optional(),
+        password: z.string().optional(),
+    })
+        .optional(),
+    args: z.array(z.string()).optional(),
+    userAgent: z.string().optional(),
+    provider: z.string().optional(),
+    ignoreHTTPSErrors: z.boolean().optional(),
+    profile: z.string().optional(),
+    storageState: z.string().optional(),
+});
+const navigateSchema = baseCommandSchema.extend({
+    action: z.literal('navigate'),
+    url: z.string().min(1),
+    waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle']).optional(),
+    headers: z.record(z.string()).optional(),
+});
+const clickSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('click'),
+    selector: z.string().min(1),
+    button: z.enum(['left', 'right', 'middle']).optional(),
+    clickCount: z.number().positive().optional(),
+    delay: z.number().nonnegative().optional(),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+    human: humanConfigSchema.optional(),
+}));
+const typeSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('type'),
+    selector: z.string().min(1),
+    text: z.string(),
+    delay: z.number().nonnegative().optional(),
+    clear: z.boolean().optional(),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+    human: humanConfigSchema.optional(),
+}));
+const fillSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('fill'),
+    selector: z.string().min(1),
+    value: z.string(),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+    human: humanConfigSchema.optional(),
+}));
+const checkSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('check'),
+    selector: z.string().min(1),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+}));
+const uncheckSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('uncheck'),
+    selector: z.string().min(1),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+}));
+const uploadSchema = baseCommandSchema.extend({
+    action: z.literal('upload'),
+    selector: z.string().min(1),
+    files: z.union([z.string(), z.array(z.string())]),
+});
+const dblclickSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('dblclick'),
+    selector: z.string().min(1),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+    human: humanConfigSchema.optional(),
+}));
+const focusSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('focus'),
+    selector: z.string().min(1),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+}));
+const dragSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('drag'),
+    source: z.string().min(1),
+    target: z.string().min(1),
+}));
+const frameSchema = baseCommandSchema.extend({
+    action: z.literal('frame'),
+    selector: z.string().min(1).optional(),
+    name: z.string().optional(),
+    url: z.string().optional(),
+});
+const mainframeSchema = baseCommandSchema.extend({
+    action: z.literal('mainframe'),
+});
+const getByRoleSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbyrole'),
+    role: z.string().min(1),
+    name: z.string().optional(),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'fill', 'check', 'hover']),
+    value: z.string().optional(),
+}));
+const getByTextSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbytext'),
+    text: z.string().min(1),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'hover']),
+}));
+const getByLabelSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbylabel'),
+    label: z.string().min(1),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'fill', 'check']),
+    value: z.string().optional(),
+}));
+const getByPlaceholderSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbyplaceholder'),
+    placeholder: z.string().min(1),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'fill']),
+    value: z.string().optional(),
+}));
+const cookiesGetSchema = baseCommandSchema.extend({
+    action: z.literal('cookies_get'),
+    urls: z.array(z.string()).optional(),
+});
+const cookiesSetSchema = baseCommandSchema.extend({
+    action: z.literal('cookies_set'),
+    cookies: z.array(z.object({
+        name: z.string(),
+        value: z.string(),
+        url: z.string().optional(),
+        domain: z.string().optional(),
+        path: z.string().optional(),
+        expires: z.number().optional(),
+        httpOnly: z.boolean().optional(),
+        secure: z.boolean().optional(),
+        sameSite: z.enum(['Strict', 'Lax', 'None']).optional(),
+    })),
+});
+const cookiesClearSchema = baseCommandSchema.extend({
+    action: z.literal('cookies_clear'),
+});
+const storageGetSchema = baseCommandSchema.extend({
+    action: z.literal('storage_get'),
+    key: z.string().optional(),
+    type: z.enum(['local', 'session']),
+});
+const storageSetSchema = baseCommandSchema.extend({
+    action: z.literal('storage_set'),
+    key: z.string().min(1),
+    value: z.string(),
+    type: z.enum(['local', 'session']),
+});
+const storageClearSchema = baseCommandSchema.extend({
+    action: z.literal('storage_clear'),
+    type: z.enum(['local', 'session']),
+});
+const dialogSchema = baseCommandSchema.extend({
+    action: z.literal('dialog'),
+    response: z.enum(['accept', 'dismiss']),
+    promptText: z.string().optional(),
+});
+const pdfSchema = baseCommandSchema.extend({
+    action: z.literal('pdf'),
+    path: z.string().min(1),
+    format: z
+        .enum(['Letter', 'Legal', 'Tabloid', 'Ledger', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6'])
+        .optional(),
+});
+const routeSchema = baseCommandSchema.extend({
+    action: z.literal('route'),
+    url: z.string().min(1),
+    response: z
+        .object({
+        status: z.number().optional(),
+        body: z.string().optional(),
+        contentType: z.string().optional(),
+        headers: z.record(z.string()).optional(),
+    })
+        .optional(),
+    abort: z.boolean().optional(),
+});
+const unrouteSchema = baseCommandSchema.extend({
+    action: z.literal('unroute'),
+    url: z.string().optional(),
+});
+const requestsSchema = baseCommandSchema.extend({
+    action: z.literal('requests'),
+    filter: z.string().optional(),
+    clear: z.boolean().optional(),
+});
+const downloadSchema = baseCommandSchema.extend({
+    action: z.literal('download'),
+    selector: z.string().min(1),
+    path: z.string().min(1),
+});
+const geolocationSchema = baseCommandSchema.extend({
+    action: z.literal('geolocation'),
+    latitude: z.number(),
+    longitude: z.number(),
+    accuracy: z.number().optional(),
+});
+const permissionsSchema = baseCommandSchema.extend({
+    action: z.literal('permissions'),
+    permissions: z.array(z.string()),
+    grant: z.boolean(),
+});
+const viewportSchema = baseCommandSchema.extend({
+    action: z.literal('viewport'),
+    width: z.number().positive(),
+    height: z.number().positive(),
+});
+const userAgentSchema = baseCommandSchema.extend({
+    action: z.literal('useragent'),
+    userAgent: z.string().min(1),
+});
+const deviceSchema = baseCommandSchema.extend({
+    action: z.literal('device'),
+    device: z.string().min(1),
+});
+const backSchema = baseCommandSchema.extend({
+    action: z.literal('back'),
+});
+const forwardSchema = baseCommandSchema.extend({
+    action: z.literal('forward'),
+});
+const reloadSchema = baseCommandSchema.extend({
+    action: z.literal('reload'),
+});
+const urlSchema = baseCommandSchema.extend({
+    action: z.literal('url'),
+});
+const titleSchema = baseCommandSchema.extend({
+    action: z.literal('title'),
+});
+const getAttributeSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getattribute'),
+    selector: z.string().min(1),
+    attribute: z.string().min(1),
+}));
+const getTextSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('gettext'),
+    selector: z.string().min(1),
+}));
+const isVisibleSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('isvisible'),
+    selector: z.string().min(1),
+}));
+const isEnabledSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('isenabled'),
+    selector: z.string().min(1),
+}));
+const isCheckedSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('ischecked'),
+    selector: z.string().min(1),
+}));
+const countSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('count'),
+    selector: z.string().min(1),
+}));
+const boundingBoxSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('boundingbox'),
+    selector: z.string().min(1),
+}));
+const stylesSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('styles'),
+    selector: z.string().min(1),
+}));
+const videoStartSchema = baseCommandSchema.extend({
+    action: z.literal('video_start'),
+    path: z.string().min(1),
+});
+const videoStopSchema = baseCommandSchema.extend({
+    action: z.literal('video_stop'),
+});
+// Recording schemas (Playwright native video recording)
+const recordingStartSchema = baseCommandSchema.extend({
+    action: z.literal('recording_start'),
+    path: z.string().min(1),
+    url: z.string().min(1).optional(),
+});
+const recordingStopSchema = baseCommandSchema.extend({
+    action: z.literal('recording_stop'),
+});
+const recordingRestartSchema = baseCommandSchema.extend({
+    action: z.literal('recording_restart'),
+    path: z.string().min(1),
+    url: z.string().min(1).optional(),
+});
+// Recorder schemas (user interaction recording)
+const recorderStartSchema = baseCommandSchema.extend({
+    action: z.literal('recorder_start'),
+    url: z.string().min(1).optional(),
+});
+const recorderStopSchema = baseCommandSchema.extend({
+    action: z.literal('recorder_stop'),
+    output: z.string().min(1).optional(),
+});
+const recorderStatusSchema = baseCommandSchema.extend({
+    action: z.literal('recorder_status'),
+});
+const recorderReplaySchema = baseCommandSchema.extend({
+    action: z.literal('recorder_replay'),
+    path: z.string().optional(),
+});
+const traceStartSchema = baseCommandSchema.extend({
+    action: z.literal('trace_start'),
+    screenshots: z.boolean().optional(),
+    snapshots: z.boolean().optional(),
+});
+const traceStopSchema = baseCommandSchema.extend({
+    action: z.literal('trace_stop'),
+    path: z.string().min(1),
+});
+const harStartSchema = baseCommandSchema.extend({
+    action: z.literal('har_start'),
+});
+const harStopSchema = baseCommandSchema.extend({
+    action: z.literal('har_stop'),
+    path: z.string().min(1),
+});
+const stateSaveSchema = baseCommandSchema.extend({
+    action: z.literal('state_save'),
+    path: z.string().min(1),
+});
+const stateLoadSchema = baseCommandSchema.extend({
+    action: z.literal('state_load'),
+    path: z.string().min(1),
+});
+const consoleSchema = baseCommandSchema.extend({
+    action: z.literal('console'),
+    clear: z.boolean().optional(),
+});
+const errorsSchema = baseCommandSchema.extend({
+    action: z.literal('errors'),
+    clear: z.boolean().optional(),
+});
+const keyboardSchema = baseCommandSchema.extend({
+    action: z.literal('keyboard'),
+    keys: z.string().min(1),
+});
+const wheelSchema = baseCommandSchema.extend({
+    action: z.literal('wheel'),
+    deltaX: z.number().optional(),
+    deltaY: z.number().optional(),
+    selector: z.string().optional(),
+});
+const tapSchema = baseCommandSchema.extend({
+    action: z.literal('tap'),
+    selector: z.string().min(1),
+});
+const clipboardSchema = baseCommandSchema.extend({
+    action: z.literal('clipboard'),
+    operation: z.enum(['copy', 'paste', 'read']),
+    text: z.string().optional(),
+});
+const highlightSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('highlight'),
+    selector: z.string().min(1),
+}));
+const clearSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('clear'),
+    selector: z.string().min(1),
+}));
+const selectAllSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('selectall'),
+    selector: z.string().min(1),
+}));
+const innerTextSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('innertext'),
+    selector: z.string().min(1),
+}));
+const innerHtmlSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('innerhtml'),
+    selector: z.string().min(1),
+}));
+const inputValueSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('inputvalue'),
+    selector: z.string().min(1),
+}));
+const setValueSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('setvalue'),
+    selector: z.string().min(1),
+    value: z.string(),
+}));
+const dispatchSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('dispatch'),
+    selector: z.string().min(1),
+    event: z.string().min(1),
+    eventInit: z.record(z.unknown()).optional(),
+}));
+const evalHandleSchema = baseCommandSchema.extend({
+    action: z.literal('evalhandle'),
+    script: z.string().min(1),
+});
+const exposeSchema = baseCommandSchema.extend({
+    action: z.literal('expose'),
+    name: z.string().min(1),
+});
+const addScriptSchema = baseCommandSchema.extend({
+    action: z.literal('addscript'),
+    content: z.string().optional(),
+    url: z.string().optional(),
+});
+const addStyleSchema = baseCommandSchema.extend({
+    action: z.literal('addstyle'),
+    content: z.string().optional(),
+    url: z.string().optional(),
+});
+const emulateMediaSchema = baseCommandSchema.extend({
+    action: z.literal('emulatemedia'),
+    media: z.enum(['screen', 'print']).nullable().optional(),
+    colorScheme: z.enum(['light', 'dark', 'no-preference']).nullable().optional(),
+    reducedMotion: z.enum(['reduce', 'no-preference']).nullable().optional(),
+    forcedColors: z.enum(['active', 'none']).nullable().optional(),
+});
+const offlineSchema = baseCommandSchema.extend({
+    action: z.literal('offline'),
+    offline: z.boolean(),
+});
+const headersSchema = baseCommandSchema.extend({
+    action: z.literal('headers'),
+    headers: z.record(z.string()),
+});
+const pauseSchema = baseCommandSchema.extend({
+    action: z.literal('pause'),
+});
+const getByAltTextSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbyalttext'),
+    text: z.string().min(1),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'hover']),
+}));
+const getByTitleSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbytitle'),
+    text: z.string().min(1),
+    exact: z.boolean().optional(),
+    subaction: z.enum(['click', 'hover']),
+}));
+const getByTestIdSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('getbytestid'),
+    testId: z.string().min(1),
+    subaction: z.enum(['click', 'fill', 'check', 'hover']),
+    value: z.string().optional(),
+}));
+const nthSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('nth'),
+    selector: z.string().min(1),
+    index: z.number(),
+    subaction: z.enum(['click', 'fill', 'check', 'hover', 'text']),
+    value: z.string().optional(),
+}));
+const waitForUrlSchema = baseCommandSchema.extend({
+    action: z.literal('waitforurl'),
+    url: z.string().min(1),
+    timeout: z.number().positive().optional(),
+});
+const waitForLoadStateSchema = baseCommandSchema.extend({
+    action: z.literal('waitforloadstate'),
+    state: z.enum(['load', 'domcontentloaded', 'networkidle']),
+    timeout: z.number().positive().optional(),
+});
+const setContentSchema = baseCommandSchema.extend({
+    action: z.literal('setcontent'),
+    html: z.string(),
+});
+const timezoneSchema = baseCommandSchema.extend({
+    action: z.literal('timezone'),
+    timezone: z.string().min(1),
+});
+const localeSchema = baseCommandSchema.extend({
+    action: z.literal('locale'),
+    locale: z.string().min(1),
+});
+const credentialsSchema = baseCommandSchema.extend({
+    action: z.literal('credentials'),
+    username: z.string(),
+    password: z.string(),
+});
+const mouseMoveSchema = baseCommandSchema.extend({
+    action: z.literal('mousemove'),
+    x: z.number(),
+    y: z.number(),
+});
+const mouseDownSchema = baseCommandSchema.extend({
+    action: z.literal('mousedown'),
+    button: z.enum(['left', 'right', 'middle']).optional(),
+});
+const mouseUpSchema = baseCommandSchema.extend({
+    action: z.literal('mouseup'),
+    button: z.enum(['left', 'right', 'middle']).optional(),
+});
+const wanderSchema = baseCommandSchema.extend({
+    action: z.literal('wander'),
+    duration: z.number().positive().optional(),
+    human: z
+        .object({
+        enabled: z.boolean(),
+        pathType: z.enum(['bezier', 'arc', 'random', 'linear']),
+    })
+        .optional(),
+});
+const mouseTrajectorySchema = baseCommandSchema.extend({
+    action: z.literal('mousetrajectory'),
+    data: z.string().min(1),
+    human: humanConfigSchema.optional(),
+});
+const bringToFrontSchema = baseCommandSchema.extend({
+    action: z.literal('bringtofront'),
+});
+const waitForFunctionSchema = baseCommandSchema.extend({
+    action: z.literal('waitforfunction'),
+    expression: z.string().min(1),
+    timeout: z.number().positive().optional(),
+});
+const scrollIntoViewSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('scrollintoview'),
+    selector: z.string().min(1),
+}));
+const addInitScriptSchema = baseCommandSchema.extend({
+    action: z.literal('addinitscript'),
+    script: z.string().min(1),
+});
+const keyDownSchema = baseCommandSchema.extend({
+    action: z.literal('keydown'),
+    key: z.string().min(1),
+});
+const keyUpSchema = baseCommandSchema.extend({
+    action: z.literal('keyup'),
+    key: z.string().min(1),
+});
+const insertTextSchema = baseCommandSchema.extend({
+    action: z.literal('inserttext'),
+    text: z.string(),
+});
+const multiSelectSchema = baseCommandSchema.extend({
+    action: z.literal('multiselect'),
+    selector: z.string().min(1),
+    values: z.array(z.string()),
+});
+const waitForDownloadSchema = baseCommandSchema.extend({
+    action: z.literal('waitfordownload'),
+    path: z.string().optional(),
+    timeout: z.number().positive().optional(),
+});
+const responseBodySchema = baseCommandSchema.extend({
+    action: z.literal('responsebody'),
+    url: z.string().min(1),
+    timeout: z.number().positive().optional(),
+});
+// Screencast schemas for streaming browser viewport
+const screencastStartSchema = baseCommandSchema.extend({
+    action: z.literal('screencast_start'),
+    format: z.enum(['jpeg', 'png']).optional(),
+    quality: z.number().min(0).max(100).optional(),
+    maxWidth: z.number().positive().optional(),
+    maxHeight: z.number().positive().optional(),
+    everyNthFrame: z.number().positive().optional(),
+});
+const screencastStopSchema = baseCommandSchema.extend({
+    action: z.literal('screencast_stop'),
+});
+// Input injection schemas for pair browsing
+const inputMouseSchema = baseCommandSchema.extend({
+    action: z.literal('input_mouse'),
+    type: z.enum(['mousePressed', 'mouseReleased', 'mouseMoved', 'mouseWheel']),
+    x: z.number(),
+    y: z.number(),
+    button: z.enum(['left', 'right', 'middle', 'none']).optional(),
+    clickCount: z.number().positive().optional(),
+    deltaX: z.number().optional(),
+    deltaY: z.number().optional(),
+    modifiers: z.number().optional(),
+});
+const inputKeyboardSchema = baseCommandSchema.extend({
+    action: z.literal('input_keyboard'),
+    type: z.enum(['keyDown', 'keyUp', 'char']),
+    key: z.string().optional(),
+    code: z.string().optional(),
+    text: z.string().optional(),
+    modifiers: z.number().optional(),
+});
+const inputTouchSchema = baseCommandSchema.extend({
+    action: z.literal('input_touch'),
+    type: z.enum(['touchStart', 'touchEnd', 'touchMove', 'touchCancel']),
+    touchPoints: z.array(z.object({
+        x: z.number(),
+        y: z.number(),
+        id: z.number().optional(),
+    })),
+    modifiers: z.number().optional(),
+});
+// iOS-specific schemas
+const swipeSchema = baseCommandSchema.extend({
+    action: z.literal('swipe'),
+    direction: z.enum(['up', 'down', 'left', 'right']),
+    distance: z.number().positive().optional(),
+});
+const deviceListSchema = baseCommandSchema.extend({
+    action: z.literal('device_list'),
+});
+const viewerSchema = baseCommandSchema.extend({
+    action: z.literal('viewer'),
+});
+const askSchema = baseCommandSchema.extend({
+    action: z.literal('ask'),
+    question: z.string().min(1),
+});
+const configSchema = baseCommandSchema.extend({
+    action: z.literal('config'),
+    json: z.boolean().optional(),
+});
+const pressSchema = baseCommandSchema.extend({
+    action: z.literal('press'),
+    key: z.string().min(1),
+    selector: z.string().min(1).optional(),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+});
+const screenshotSchema = baseCommandSchema.extend({
+    action: z.literal('screenshot'),
+    path: z.string().nullable().optional(),
+    fullPage: z.boolean().optional(),
+    selector: z.string().min(1).nullish(),
+    format: z.enum(['png', 'jpeg']).optional(),
+    quality: z.number().min(0).max(100).optional(),
+});
+const snapshotSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('snapshot'),
+    interactive: z.boolean().optional(),
+    maxDepth: z.number().nonnegative().optional(),
+    compact: z.boolean().optional(),
+    selector: z.string().optional(),
+    cursor: z.boolean().optional(),
+    path: z.boolean().optional(),
+    attrs: z.boolean().optional(),
+}));
+const evaluateSchema = baseCommandSchema.extend({
+    action: z.literal('evaluate'),
+    script: z.string().min(1).optional(),
+    file: z.string().min(1).optional(),
+    args: z.array(z.unknown()).optional(),
+});
+const waitSchema = baseCommandSchema.extend({
+    action: z.literal('wait'),
+    selector: z.string().min(1).optional(),
+    timeout: z.number().positive().optional(),
+    state: z.enum(['attached', 'detached', 'visible', 'hidden']).optional(),
+});
+const scrollSchema = baseCommandSchema.extend({
+    action: z.literal('scroll'),
+    selector: z.string().min(1).optional(),
+    x: z.number().optional(),
+    y: z.number().optional(),
+    direction: z.enum(['up', 'down', 'left', 'right']).optional(),
+    amount: z.number().positive().optional(),
+});
+const selectSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('select'),
+    selector: z.string().min(1),
+    values: z.union([z.string(), z.array(z.string())]),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+}));
+const hoverSchema = withFrame(baseCommandSchema.extend({
+    action: z.literal('hover'),
+    selector: z.string().min(1),
+    diffScope: z.union([z.number(), z.literal('full'), z.string()]).optional(),
+    human: humanConfigSchema.optional(),
+}));
+const contentSchema = baseCommandSchema.extend({
+    action: z.literal('content'),
+    selector: z.string().min(1).optional(),
+});
+const closeSchema = baseCommandSchema.extend({
+    action: z.literal('close'),
+});
+// Tab/Window schemas
+const tabNewSchema = baseCommandSchema.extend({
+    action: z.literal('tab_new'),
+    url: z.string().min(1).optional(),
+});
+const tabListSchema = baseCommandSchema.extend({
+    action: z.literal('tab_list'),
+});
+const tabSwitchSchema = baseCommandSchema.extend({
+    action: z.literal('tab_switch'),
+    index: z.number().nonnegative(),
+});
+const tabCloseSchema = baseCommandSchema.extend({
+    action: z.literal('tab_close'),
+    index: z.number().nonnegative().optional(),
+});
+const windowNewSchema = baseCommandSchema.extend({
+    action: z.literal('window_new'),
+    viewport: z
+        .object({
+        width: z.number().positive(),
+        height: z.number().positive(),
+    })
+        .optional(),
+});
+// Union schema for all commands
+const commandSchema = z.discriminatedUnion('action', [
+    launchSchema,
+    navigateSchema,
+    clickSchema,
+    typeSchema,
+    fillSchema,
+    checkSchema,
+    uncheckSchema,
+    uploadSchema,
+    dblclickSchema,
+    focusSchema,
+    dragSchema,
+    frameSchema,
+    mainframeSchema,
+    getByRoleSchema,
+    getByTextSchema,
+    getByLabelSchema,
+    getByPlaceholderSchema,
+    pressSchema,
+    screenshotSchema,
+    snapshotSchema,
+    evaluateSchema,
+    waitSchema,
+    scrollSchema,
+    selectSchema,
+    hoverSchema,
+    contentSchema,
+    closeSchema,
+    tabNewSchema,
+    tabListSchema,
+    tabSwitchSchema,
+    tabCloseSchema,
+    windowNewSchema,
+    cookiesGetSchema,
+    cookiesSetSchema,
+    cookiesClearSchema,
+    storageGetSchema,
+    storageSetSchema,
+    storageClearSchema,
+    dialogSchema,
+    pdfSchema,
+    routeSchema,
+    unrouteSchema,
+    requestsSchema,
+    downloadSchema,
+    geolocationSchema,
+    permissionsSchema,
+    viewportSchema,
+    userAgentSchema,
+    deviceSchema,
+    backSchema,
+    forwardSchema,
+    reloadSchema,
+    urlSchema,
+    titleSchema,
+    getAttributeSchema,
+    getTextSchema,
+    isVisibleSchema,
+    isEnabledSchema,
+    isCheckedSchema,
+    countSchema,
+    boundingBoxSchema,
+    stylesSchema,
+    videoStartSchema,
+    videoStopSchema,
+    recordingStartSchema,
+    recordingStopSchema,
+    recordingRestartSchema,
+    recorderStartSchema,
+    recorderStopSchema,
+    recorderStatusSchema,
+    recorderReplaySchema,
+    traceStartSchema,
+    traceStopSchema,
+    harStartSchema,
+    harStopSchema,
+    stateSaveSchema,
+    stateLoadSchema,
+    consoleSchema,
+    errorsSchema,
+    keyboardSchema,
+    wheelSchema,
+    tapSchema,
+    clipboardSchema,
+    highlightSchema,
+    clearSchema,
+    selectAllSchema,
+    innerTextSchema,
+    innerHtmlSchema,
+    inputValueSchema,
+    setValueSchema,
+    dispatchSchema,
+    evalHandleSchema,
+    exposeSchema,
+    addScriptSchema,
+    addStyleSchema,
+    emulateMediaSchema,
+    offlineSchema,
+    headersSchema,
+    pauseSchema,
+    getByAltTextSchema,
+    getByTitleSchema,
+    getByTestIdSchema,
+    nthSchema,
+    waitForUrlSchema,
+    waitForLoadStateSchema,
+    setContentSchema,
+    timezoneSchema,
+    localeSchema,
+    credentialsSchema,
+    mouseMoveSchema,
+    mouseDownSchema,
+    mouseUpSchema,
+    wanderSchema,
+    mouseTrajectorySchema,
+    bringToFrontSchema,
+    waitForFunctionSchema,
+    scrollIntoViewSchema,
+    addInitScriptSchema,
+    keyDownSchema,
+    keyUpSchema,
+    insertTextSchema,
+    multiSelectSchema,
+    waitForDownloadSchema,
+    responseBodySchema,
+    screencastStartSchema,
+    screencastStopSchema,
+    inputMouseSchema,
+    inputKeyboardSchema,
+    inputTouchSchema,
+    swipeSchema,
+    deviceListSchema,
+    viewerSchema,
+    askSchema,
+    configSchema,
+]);
+/**
+ * Parse a JSON string into a validated command
+ */
+export function parseCommand(input) {
+    // First, try to parse JSON
+    let json;
+    try {
+        json = JSON.parse(input);
+    }
+    catch {
+        return { success: false, error: 'Invalid JSON' };
+    }
+    // Extract id for error responses if possible
+    const id = typeof json === 'object' && json !== null && 'id' in json
+        ? String(json.id)
+        : undefined;
+    // Validate against schema
+    const result = commandSchema.safeParse(json);
+    if (!result.success) {
+        const errors = result.error.errors.map((e) => `${e.path.join('.')}: ${e.message}`).join(', ');
+        return { success: false, error: `Validation error: ${errors}`, id };
+    }
+    return { success: true, command: result.data };
+}
+/**
+ * Create a success response
+ */
+export function successResponse(id, data, tips) {
+    const response = { id, success: true, data };
+    if (tips)
+        response.tips = tips;
+    return response;
+}
+/**
+ * Create an error response
+ */
+export function errorResponse(id, error) {
+    return { id, success: false, error };
+}
+/**
+ * Serialize a response to JSON string
+ */
+export function serializeResponse(response) {
+    return JSON.stringify(response);
+}
+//# sourceMappingURL=protocol.js.map