extension.js · part 7

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/extensions/cursor-browser-automation/dist/extension.js, part 7. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

- Failed refs: ${t.join("; ")}

No browser tab available. Please navigate to a page first.

Error: Missing required "values" parameter.

The browser_select_option tool requires a "values" array containing the option(s) to select.

Example usage:
- Single select: { ref: "e123", values: ["optionValue"] }
- Multi-select: { ref: "e123", values: ["value1", "value2"] }

Values can be option values or labels. Take a snapshot to see available options.

Error: Empty "values" array provided.

Provide at least one value to select. Take a snapshot to see available options for this select element.

					${q}
					${c}
					(async function() {
						const ref = ${JSON.stringify(r)};
						const { element } = findElementByRef(ref);
						if (!element) throw new Error('Element not found: ' + ref + '. Take a snapshot to get updated refs.');

						const selectElement = element;
						if (selectElement.tagName.toUpperCase() !== 'SELECT') {
							throw new Error('Element ' + ref + ' is not a select element (found: ' + selectElement.tagName.toLowerCase() + ').');
						}

						if (selectElement.disabled) {
							throw new Error('Select element ' + ref + ' is disabled and cannot be interacted with.');
						}

						const rect = selectElement.getBoundingClientRect();
						const scrollPadding = 50;
						const needsScroll = rect.top < scrollPadding || rect.left < scrollPadding ||
							rect.bottom > window.innerHeight - scrollPadding || rect.right > window.innerWidth - scrollPadding;
						if (needsScroll) {
							selectElement.scrollIntoView({ block: 'center', inline: 'center', behavior: 'smooth' });
							await new Promise(r => setTimeout(r, 300));
						}

						selectElement.focus();
						await new Promise(r => setTimeout(r, 0));

						const values = ${JSON.stringify(t.values)};

						const availableOptions = Array.from(selectElement.options).map(o => ({
							value: o.value,
							label: o.textContent?.trim() || o.label || '',
							disabled: o.disabled
						}));

						if (values.length > 1 && !selectElement.multiple) {
							throw new Error('Cannot select multiple values on a single-select dropdown. The select element does not have the "multiple" attribute. Use a single value instead, or interact with the correct multi-select element.');
						}

						if (!selectElement.multiple) {
							selectElement.value = '';
						} else {
							Array.from(selectElement.options).forEach(option => {
								option.selected = false;
							});
						}

						const selectedValues = [];
						const matchedBy = [];
						for (const value of values) {
							let optionFound = false;
							for (const option of selectElement.options) {
								if (option.value === value) {
									if (option.disabled) {
										throw new Error('Option "' + value + '" is disabled and cannot be selected.');
									}
									option.selected = true;
									selectedValues.push(option.value);
									matchedBy.push('value');
									optionFound = true;
									break;
								}
							}
							if (!optionFound) {
								for (const option of selectElement.options) {
									const labelText = (option.textContent?.trim() || option.label || '').toLowerCase();
									if (labelText === value.toLowerCase()) {
										if (option.disabled) {
											throw new Error('Option with label "' + value + '" is disabled and cannot be selected.');
										}
										option.selected = true;
										selectedValues.push(option.value);
										matchedBy.push('label');
										optionFound = true;
										break;
									}
								}
							}
							if (!optionFound) {
								for (const option of selectElement.options) {
									const labelText = (option.textContent?.trim() || option.label || '').toLowerCase();
									if (labelText.includes(value.toLowerCase())) {
										if (option.disabled) {
											throw new Error('Option containing "' + value + '" is disabled and cannot be selected.');
										}
										option.selected = true;
										selectedValues.push(option.value);
										matchedBy.push('partial label');
										optionFound = true;
										break;
									}
								}
							}
							if (!optionFound) {
								const optionList = availableOptions.slice(0, 8).map(o =>
									'"' + o.label + '"' + (o.value !== o.label ? ' (value: ' + o.value + ')' : '') + (o.disabled ? ' [disabled]' : '')
								).join(', ');
								const isMultiple = selectElement.multiple ? ' (multi-select)' : ' (single-select)';
								throw new Error('Option "' + value + '" not found in select element' + isMultiple + '. Available options: ' + optionList + (availableOptions.length > 8 ? '...' : '') + '. Try using the exact option value or label.');
							}
						}

						selectElement.dispatchEvent(new Event('input', { bubbles: true }));
						selectElement.dispatchEvent(new Event('change', { bubbles: true }));

						const snapshotResult = buildPageSnapshot();
						return {
							success: true,
							selectedValues,
							matchedBy,
							availableOptions: availableOptions.slice(0, 10),
							pageState: {
								url: window.location.href,
								title: document.title,
								snapshot: snapshotResult.tree
							}
						};
					})();
				

${t} (matched by ${s.matchedBy[e]||"value"})

- Selected: ${t.join(", ")}

- Selected values: (none)

No browser tab available. Please navigate to a page first.

				(function() {
					const keyInput = ${JSON.stringify(t.key)};

					const keyCodeMap = {
						'PageDown': 34, 'PageUp': 33, 'End': 35, 'Home': 36,
						'ArrowLeft': 37, 'ArrowUp': 38, 'ArrowRight': 39, 'ArrowDown': 40,
						'Enter': 13, 'Escape': 27, 'Tab': 9, 'Backspace': 8, 'Delete': 46,
						'Space': 32, ' ': 32, 'F1': 112, 'F2': 113, 'F3': 114, 'F4': 115,
						'F5': 116, 'F6': 117, 'F7': 118, 'F8': 119, 'F9': 120, 'F10': 121,
						'F11': 122, 'F12': 123, 'Insert': 45, 'NumLock': 144, 'ScrollLock': 145,
						'Pause': 19, 'CapsLock': 20
					};

					const codeMap = {
						'a': 'KeyA', 'b': 'KeyB', 'c': 'KeyC', 'd': 'KeyD', 'e': 'KeyE',
						'f': 'KeyF', 'g': 'KeyG', 'h': 'KeyH', 'i': 'KeyI', 'j': 'KeyJ',
						'k': 'KeyK', 'l': 'KeyL', 'm': 'KeyM', 'n': 'KeyN', 'o': 'KeyO',
						'p': 'KeyP', 'q': 'KeyQ', 'r': 'KeyR', 's': 'KeyS', 't': 'KeyT',
						'u': 'KeyU', 'v': 'KeyV', 'w': 'KeyW', 'x': 'KeyX', 'y': 'KeyY', 'z': 'KeyZ',
						'0': 'Digit0', '1': 'Digit1', '2': 'Digit2', '3': 'Digit3', '4': 'Digit4',
						'5': 'Digit5', '6': 'Digit6', '7': 'Digit7', '8': 'Digit8', '9': 'Digit9',
						' ': 'Space', 'Space': 'Space',
						'Enter': 'Enter', 'Tab': 'Tab', 'Escape': 'Escape', 'Backspace': 'Backspace',
						'Delete': 'Delete', 'Insert': 'Insert',
						'ArrowUp': 'ArrowUp', 'ArrowDown': 'ArrowDown', 'ArrowLeft': 'ArrowLeft', 'ArrowRight': 'ArrowRight',
						'Home': 'Home', 'End': 'End', 'PageUp': 'PageUp', 'PageDown': 'PageDown',
						'F1': 'F1', 'F2': 'F2', 'F3': 'F3', 'F4': 'F4', 'F5': 'F5', 'F6': 'F6',
						'F7': 'F7', 'F8': 'F8', 'F9': 'F9', 'F10': 'F10', 'F11': 'F11', 'F12': 'F12',
						'-': 'Minus', '=': 'Equal', '[': 'BracketLeft', ']': 'BracketRight',
						'\\': 'Backslash', ';': 'Semicolon', "'": 'Quote', ',': 'Comma',
						'.': 'Period', '/': 'Slash', '`': 'Backquote'
					};

					const scrollAmounts = {
						'PageDown': { x: 0, y: window.innerHeight * 0.8 },
						'PageUp': { x: 0, y: -window.innerHeight * 0.8 },
						'ArrowDown': { x: 0, y: 40 },
						'ArrowUp': { x: 0, y: -40 },
						'End': { x: 0, y: document.documentElement.scrollHeight - window.scrollY },
						'Home': { x: 0, y: -window.scrollY },
						'Space': { x: 0, y: window.innerHeight * 0.8 },
						' ': { x: 0, y: window.innerHeight * 0.8 },
					};

					const modifierAliases = {
						'Control': ['Control', 'Ctrl', 'control', 'ctrl'],
						'Shift': ['Shift', 'shift'],
						'Alt': ['Alt', 'alt', 'Option', 'option'],
						'Meta': ['Meta', 'meta', 'Command', 'command', 'Cmd', 'cmd', 'Win', 'win']
					};

					function parseKeyCombo(input) {
						const parts = input.split('+').map(p => p.trim());
						const modifiers = { ctrlKey: false, shiftKey: false, altKey: false, metaKey: false };
						let mainKey = '';

						for (const part of parts) {
							let isModifier = false;
							for (const [mod, aliases] of Object.entries(modifierAliases)) {
								if (aliases.includes(part)) {
									if (mod === 'Control') modifiers.ctrlKey = true;
									else if (mod === 'Shift') modifiers.shiftKey = true;
									else if (mod === 'Alt') modifiers.altKey = true;
									else if (mod === 'Meta') modifiers.metaKey = true;
									isModifier = true;
									break;
								}
							}
							if (!isModifier) {
								mainKey = part;
							}
						}

						return { modifiers, mainKey };
					}

					const { modifiers, mainKey } = parseKeyCombo(keyInput);
					const key = mainKey || keyInput;

					const keyLower = key.toLowerCase();
					const code = codeMap[key] || codeMap[keyLower] || (key.length === 1 ? 'Key' + key.toUpperCase() : key);
					const keyCode = keyCodeMap[key] || (key.length === 1 ? key.toUpperCase().charCodeAt(0) : 0);

					const activeElement = document.activeElement || document.body;

					const scrollKeys = ['PageDown', 'PageUp', 'Home', 'End'];
					if (scrollKeys.includes(key) && !modifiers.ctrlKey && !modifiers.altKey && !modifiers.metaKey) {
						const isScrollable = (el) => {
							if (!el || !(el instanceof HTMLElement)) return false;
							const style = getComputedStyle(el);
							const overflowY = style.overflowY;
							return (overflowY === 'auto' || overflowY === 'scroll') && el.scrollHeight > el.clientHeight;
						};

						let scrollable = null;
						let current = activeElement;
						while (current && current !== document.body) {
							if (isScrollable(current)) {
								scrollable = current;
								break;
							}
							current = current.parentElement;
						}

						if (!scrollable) {
							scrollable = document.scrollingElement || document.documentElement;
						}

						const viewportHeight = scrollable.clientHeight;

						switch (key) {
							case 'PageDown':
								scrollable.scrollBy({ top: viewportHeight, behavior: 'instant' });
								break;
							case 'PageUp':
								scrollable.scrollBy({ top: -viewportHeight, behavior: 'instant' });
								break;
							case 'Home':
								scrollable.scrollTo({ top: 0, behavior: 'instant' });
								break;
							case 'End':
								scrollable.scrollTo({ top: scrollable.scrollHeight, behavior: 'instant' });
								break;
						}
					} else if (scrollAmounts[key] && !modifiers.ctrlKey && !modifiers.altKey && !modifiers.metaKey) {
						window.scrollBy({ left: scrollAmounts[key].x, top: scrollAmounts[key].y, behavior: 'smooth' });
					}

					const eventInit = {
						key: key,
						code: code,
						keyCode: keyCode,
						which: keyCode,
						bubbles: true,
						cancelable: true,
						ctrlKey: modifiers.ctrlKey,
						shiftKey: modifiers.shiftKey,
						altKey: modifiers.altKey,
						metaKey: modifiers.metaKey
					};

					activeElement.dispatchEvent(new KeyboardEvent('keydown', eventInit));

					if (key.length === 1 && !modifiers.ctrlKey && !modifiers.altKey && !modifiers.metaKey) {
						activeElement.dispatchEvent(new KeyboardEvent('keypress', eventInit));

						if (activeElement.tagName === 'INPUT' || activeElement.tagName === 'TEXTAREA' || activeElement.isContentEditable) {
							const inputEvent = new InputEvent('beforeinput', {
								bubbles: true,
								cancelable: true,
								inputType: 'insertText',
								data: key
							});
							activeElement.dispatchEvent(inputEvent);
						}
					}

					activeElement.dispatchEvent(new KeyboardEvent('keyup', eventInit));

					const modifierStr = [
						modifiers.ctrlKey ? 'Ctrl' : '',
						modifiers.shiftKey ? 'Shift' : '',
						modifiers.altKey ? 'Alt' : '',
						modifiers.metaKey ? 'Meta' : ''
					].filter(Boolean).join('+');

					return {
						action: 'press_key',
						success: true,
						key: key,
						code: code,
						modifiers: modifierStr || 'none',
						fullCombo: modifierStr ? modifierStr + '+' + key : key
					};
				})();
			

Successfully pressed key: ${o.fullCombo} (code: ${o.code})

Failed to press key: ${o.key}

No browser tab available. Please navigate to a page first.

Error: Either targetRef or both targetX and targetY must be provided for drag operation.

Suggestion: Specify where to drop the element using targetRef (for element-to-element drag) or targetX/targetY coordinates.

					(async function() {
						${q}

						const sourceRef = ${JSON.stringify(r)};
						const targetRef = ${JSON.stringify(o)};
						const targetX = ${t.targetX??"null"};
						const targetY = ${t.targetY??"null"};

						const { element: sourceElement } = findElementByRef(sourceRef);
						if (!sourceElement) {
							return {
								success: false,
								error: 'Source element not found: ' + sourceRef + '. Take a snapshot to get updated refs.',
								suggestion: 'The source element reference may be stale. Take a new snapshot to get current element refs.'
							};
						}

						const sourceStyle = window.getComputedStyle(sourceElement);
						const isDraggable = sourceElement.draggable || sourceElement.getAttribute('draggable') === 'true';
						if (!isDraggable && sourceStyle.cursor !== 'grab' && sourceStyle.cursor !== 'move') {
							return {
								success: false,
								error: 'Source element ' + sourceRef + ' does not appear to be draggable. It lacks the draggable attribute.',
								suggestion: 'Verify the element is meant to be dragged. Check if it has draggable="true" attribute or is part of a drag-and-drop library that uses different mechanisms.'
							};
						}

						let targetElement = null;
						if (targetRef) {
							const targetResult = findElementByRef(targetRef);
							targetElement = targetResult.element;
							if (!targetElement) {
								return {
									success: false,
									error: 'Target element not found: ' + targetRef + '. Take a snapshot to get updated refs.',
									suggestion: 'The target element reference may be stale. Take a new snapshot to get current element refs.'
								};
							}
						}

						const sourceRect = sourceElement.getBoundingClientRect();
						const startX = Math.round(sourceRect.left + sourceRect.width / 2);
						const startY = Math.round(sourceRect.top + sourceRect.height / 2);

						let dropX, dropY;
						if (targetElement) {
							const targetRect = targetElement.getBoundingClientRect();
							dropX = Math.round(targetRect.left + targetRect.width / 2);
							dropY = Math.round(targetRect.top + targetRect.height / 2);
						} else {
							dropX = targetX;
							dropY = targetY;
						}

						try {
							const dataTransfer = new DataTransfer();
							dataTransfer.effectAllowed = 'all';

							const pointerOpts = {
								bubbles: true,
								cancelable: true,
								view: window,
								pointerId: 1,
								pointerType: 'mouse',
								isPrimary: true,
								button: 0,
								buttons: 1
							};

							sourceElement.dispatchEvent(new PointerEvent('pointerover', { ...pointerOpts, clientX: startX, clientY: startY }));
							sourceElement.dispatchEvent(new PointerEvent('pointerenter', { ...pointerOpts, clientX: startX, clientY: startY, bubbles: false }));
							sourceElement.dispatchEvent(new MouseEvent('mouseover', { bubbles: true, clientX: startX, clientY: startY }));
							sourceElement.dispatchEvent(new MouseEvent('mouseenter', { bubbles: false, clientX: startX, clientY: startY }));

							sourceElement.dispatchEvent(new PointerEvent('pointerdown', { ...pointerOpts, clientX: startX, clientY: startY }));
							sourceElement.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true, clientX: startX, clientY: startY, button: 0 }));

							await new Promise(r => setTimeout(r, 50));

							const dragStartEvent = new DragEvent('dragstart', {
								bubbles: true,
								cancelable: true,
								clientX: startX,
								clientY: startY,
								dataTransfer: dataTransfer
							});
							const dragStarted = sourceElement.dispatchEvent(dragStartEvent);

							if (!dragStarted) {
								return {
									success: false,
									error: 'Drag start was prevented by the page.',
									suggestion: 'The page may have event handlers preventing drag. Try using browser_evaluate to trigger the drag programmatically.'
								};
							}

							sourceElement.dispatchEvent(new DragEvent('drag', {
								bubbles: true,
								cancelable: true,
								clientX: startX,
								clientY: startY,
								dataTransfer: dataTransfer
							}));

							await new Promise(r => setTimeout(r, 50));

							const dropTarget = targetElement || document.elementFromPoint(dropX, dropY);
							if (!dropTarget) {
								return {
									success: false,
									error: 'No element found at drop coordinates (' + dropX + ', ' + dropY + ').',
									suggestion: 'Verify the target coordinates are within the viewport and point to a valid drop zone.'
								};
							}

							dropTarget.dispatchEvent(new DragEvent('dragenter', {
								bubbles: true,
								cancelable: true,
								clientX: dropX,
								clientY: dropY,
								dataTransfer: dataTransfer
							}));

							const dragOverEvent = new DragEvent('dragover', {
								bubbles: true,
								cancelable: true,
								clientX: dropX,
								clientY: dropY,
								dataTransfer: dataTransfer
							});
							dropTarget.dispatchEvent(dragOverEvent);

							await new Promise(r => setTimeout(r, 50));

							const dropEvent = new DragEvent('drop', {
								bubbles: true,
								cancelable: true,
								clientX: dropX,
								clientY: dropY,
								dataTransfer: dataTransfer
							});
							const dropAccepted = dropTarget.dispatchEvent(dropEvent);

							sourceElement.dispatchEvent(new DragEvent('dragend', {
								bubbles: true,
								cancelable: false,
								clientX: dropX,
								clientY: dropY,
								dataTransfer: dataTransfer
							}));

							sourceElement.dispatchEvent(new PointerEvent('pointerup', { ...pointerOpts, clientX: dropX, clientY: dropY }));
							sourceElement.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, clientX: dropX, clientY: dropY }));

							return {
								success: true,
								action: 'drag',
								source: sourceRef,
								target: targetRef || ('(' + dropX + ', ' + dropY + ')'),
								dropAccepted: dropAccepted,
								message: 'Drag completed from ' + sourceRef + ' to ' + (targetRef || 'coordinates (' + dropX + ', ' + dropY + ')') + (dropAccepted ? '' : ' (drop may not have been accepted by target)')
							};
						} catch (err) {
							return {
								success: false,
								error: 'Drag operation failed: ' + (err instanceof Error ? err.message : String(err)),
								suggestion: 'The drag-and-drop may use a library (like react-dnd or sortablejs) that requires specific event sequences. Try using browser_evaluate to interact with the library directly.'
							};
						}
					})();
				

### Action: drag
- ${i.message}
- Source: ${i.source}
- Target: ${i.target}

Error: ${i.error||"Unknown drag error"}

Suggestion: ${i.suggestion||"Take a snapshot to verify the elements are draggable."}

Recovery action: browser_snapshot

Unknown drag error

Take a snapshot to verify the elements are draggable.

Browser snapshot push failed (${t}): ${n instanceof Error?n.message:String(n)}

Browser snapshot push retries exhausted (${t}); entering recovery backfill loop

The cursor-ide-browser MCP server provides a Cursor-owned browser tab plus a raw Chrome DevTools Protocol command tool.

CORE WORKFLOW:
1. Start by understanding the user's goal and what success looks like on the page.
2. Use browser_tabs with action "list" to inspect open tabs and URLs before acting.
3. Use browser_navigate to create or navigate the target tab. Omit the position parameter for background automation so focus is preserved.
4. Use browser_lock before longer automation on an existing tab, then browser_lock with action "unlock" when finished.
5. Use browser_snapshot for accessibility context and browser_take_screenshot for visual verification.
6. Use browser_click, browser_type, browser_fill, browser_select_option, browser_press_key, browser_scroll, and browser_drag for page interactions.
7. Use browser_highlight and browser_get_bounding_box for visual grounding and coordinate diagnostics.
8. Use browser_cdp for page inspection, profiling, runtime evaluation, DOM/CSS queries, and performance data.

AVOID RABBIT HOLES:
1. Do not repeat the same failing action more than once without new evidence such as a fresh snapshot, a different ref, a changed page state, or a clear new hypothesis.
2. IMPORTANT: If four attempts fail or progress stalls, stop acting and report what you observed, what blocked progress, and the most likely next step.
3. Prefer gathering evidence over brute force. If the page is confusing, use browser_snapshot, browser_take_screenshot, or CDP inspection before trying more actions.
4. If you encounter a blocker such as login, passkey/manual user interaction, permissions, captchas, destructive confirmations, missing data, or an unexpected state, stop and report it instead of improvising repeated actions.
5. Do not get stuck in wait-action-wait loops. Every retry should be justified by something newly observed.

CRITICAL - Lock/unlock workflow:
1. browser_lock requires an existing browser tab - you CANNOT call browser_lock with action: "lock" before browser_navigate
2. Correct order: browser_navigate -> browser_lock({ action: "lock" }) -> (interactions) -> browser_lock({ action: "unlock" })
3. If a browser tab already exists (check with browser_tabs list), call browser_lock with action: "lock" FIRST before any interactions
4. Only call browser_lock with action: "unlock" when completely done with ALL browser operations for this turn

IMPORTANT - Waiting strategy:
When waiting for page changes, prefer short CDP polling loops with Runtime.evaluate, DOM queries, Page lifecycle signals, or browser_snapshot checks rather than a single long wait.

CDP USAGE:
- Use browser_cdp with a DevTools Protocol method and params object, for example Runtime.evaluate, DOM.getDocument, CSS.getComputedStyleForNode, Profiler.start/stop, Performance.getMetrics, Log.enable, and Network.enable.
- Do not use browser_cdp with CDP Input.* methods. They are denied because they are focus-sensitive in Electron webviews and can route input to Cursor UI instead of the browser page.
- Use browser_click, browser_type, browser_fill, browser_select_option, browser_press_key, browser_scroll, and browser_drag for clicks, typing, filling inputs, selecting options, keyboard actions, scrolling, and drag-and-drop.
- Use Runtime.evaluate for advanced DOM-scoped interactions that the dedicated browser tools do not cover.
- For profiling, call Profiler.enable, Profiler.start, reproduce the behavior, then Profiler.stop. The profile is saved to a file and returned as a log_file; read that file only when you need to inspect details.
- For JavaScript evaluation, prefer Runtime.evaluate with returnByValue when possible.
- Device emulation you set with Emulation.setDeviceMetricsOverride, Emulation.setTouchEmulationEnabled, or Emulation.setUserAgentOverride (for example for a phone-sized screenshot) lasts only for the current turn: it is cleared when your turn ends, and the user can reset it from the browser tab at any time. Send Emulation.clearDeviceMetricsOverride yourself once you are done with it within a turn.
- Some browser-wide or sensitive CDP methods are denied, especially cookie, storage, permission, download, target-management, filesystem-backed file-input commands, system-level commands, and CDP navigation/history navigation commands.
- Large CDP responses are saved to files instead of being inlined. Prefer using the returned file path over immediately stuffing large payloads into context; read focused sections only when needed.

VISION:
- browser_take_screenshot attaches an image result that the model can inspect. CDP Page.captureScreenshot returns data inside JSON and should not replace browser_take_screenshot when visual verification is needed.

NOTES:
- browser_snapshot returns snapshot YAML and is the main source of truth for page structure.
- Refs are opaque handles tied to the latest browser_snapshot for that tab.
- Iframe content is not accessible - only elements outside iframes can be interacted with.
- When you stop to report a blocker, include the current page, the target you were trying to reach, the blocker you observed, and the best next action. If the blocker requires manual user interaction, ask the user to take over at that point rather than assuming it in advance.

Navigate to a URL. By default reuses an existing tab; set newTab: true to open in a new tab.

The URL to navigate to

Target browser tab ID. If omitted, uses the last interacted tab.

Only set when the user explicitly asks to reveal, show, focus, or open the browser visibly. Set to "active" for visible/revealed browser UI, or "side" if the user mentions "side", "beside", "side panel", or "side by side". Omit this parameter for background automation so focus is preserved.

When true, takes a screenshot after navigation completes. Defaults to false.

When true, creates a new tab before navigating instead of reusing an existing tab. Defaults to false.

Capture accessibility snapshot of the current page, this is better than screenshot

Target browser tab ID. If omitted, uses the last interacted tab.

When true, only include interactive elements in the snapshot. Defaults to false.

Maximum depth for snapshot output. Defaults to 20.

When true, outputs a more compact snapshot format. Defaults to false.

Optional CSS selector to scope the snapshot to a subtree.

When true, include a diff vs the previous snapshot for this tab. Defaults to false.

When true, takes a screenshot after snapshot completes. Defaults to false.

Click an element by ref from browser_snapshot. Use this instead of CDP Input.* methods.

Element ref from browser_snapshot.

Human-readable description of the element.

Optional x offset from the element center.

Optional y offset from the element center.

When true, double-click the element.

Mouse button. Defaults to left.

Optional modifier keys.

Optional mouse hold duration before release.

Target browser tab ID. If omitted, uses the last interacted tab.

When true, takes a screenshot after the click completes. Defaults to false.

Click at viewport coordinates. Prefer browser_click with refs when possible.

Viewport x coordinate.

Viewport y coordinate.

Mouse button. Defaults to left.

Target browser tab ID. If omitted, uses the last interacted tab.

When true, takes a screenshot after the click completes. Defaults to false.

Type text into an input, textarea, or contenteditable element by ref.

Element ref from browser_snapshot.

Text to type.

Human-readable description of the element.

When true, clear existing text first.

When true, press Enter after typing.

When true, type character by character.