extension.js · part 6

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

File contents and all parts · All files

Unknown action: ${e.action}

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

				${c}
				(function() {
					const options = ${JSON.stringify(r)};
					const result = buildPageSnapshot(options);
					return {
						success: true,
						pageState: {
							url: window.location.href,
							title: document.title,
							snapshot: result.tree
						},
						stats: result.stats
					};
				})();
			

Browser tab is detached or unresponsive. Retry browser_navigate to recreate it.

- Total refs: ${s.stats.totalRefs}

- Interactive refs: ${s.stats.interactiveRefs}

- Filter: interactive only

- Filter: compact mode

- Selector: ${t.selector}

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

${"Profiler.stop"===e.method?"Profile data can be large, so it was saved to a file instead of being inlined.":"CDP response exceeded 25000 characters, so it was saved to a file instead of being inlined."}
File: ${t}

Profile data can be large, so it was saved to a file instead of being inlined.

CDP response exceeded 25000 characters, so it was saved to a file instead of being inlined.

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

screen shot timed out, please try again

Screenshot failed: ${a.error||"Unknown error"}

Unknown error

Screenshot captured successfully

Filename: ${a.filename}

Saved to: ${a.savedPath}

Screenshot saved to: ${a.savedPath}

Screenshot captured but no image data available

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

				(async function() {
					${q}

					const ref = ${JSON.stringify(a)};
					const deltaX = ${r};
					const deltaY = ${o};
					const scrollIntoView = ${i};

					function getScrollableAncestors(el) {
						const ancestors = [];
						let current = el.parentElement;
						while (current && current !== document.body && current !== document.documentElement) {
							const style = window.getComputedStyle(current);
							const overflowY = style.overflowY;
							const overflowX = style.overflowX;
							const isScrollable = (
								(overflowY === 'auto' || overflowY === 'scroll' || overflowX === 'auto' || overflowX === 'scroll') &&
								(current.scrollHeight > current.clientHeight || current.scrollWidth > current.clientWidth)
							);
							if (isScrollable) {
								ancestors.push(current);
							}
							current = current.parentElement;
						}
						return ancestors;
					}

					function isElementVisibleInContainer(el, container) {
						const elRect = el.getBoundingClientRect();
						const containerRect = container.getBoundingClientRect();
						const padding = 10;
						return (
							elRect.top >= containerRect.top - padding &&
							elRect.bottom <= containerRect.bottom + padding &&
							elRect.left >= containerRect.left - padding &&
							elRect.right <= containerRect.right + padding
						);
					}

					function scrollElementIntoContainer(el, container) {
						const elRect = el.getBoundingClientRect();
						const containerRect = container.getBoundingClientRect();

						let scrollTopDelta = 0;
						let scrollLeftDelta = 0;

						const elCenterY = elRect.top + elRect.height / 2;
						const containerCenterY = containerRect.top + containerRect.height / 2;
						const elCenterX = elRect.left + elRect.width / 2;
						const containerCenterX = containerRect.left + containerRect.width / 2;

						scrollTopDelta = elCenterY - containerCenterY;
						scrollLeftDelta = elCenterX - containerCenterX;

						if (Math.abs(scrollTopDelta) > 5 || Math.abs(scrollLeftDelta) > 5) {
							container.scrollBy({ top: scrollTopDelta, left: scrollLeftDelta, behavior: 'instant' });
							return true;
						}
						return false;
					}

					if (ref) {
						const { element } = findElementByRef(ref);
						if (!element) {
							return {
								success: false,
								error: 'Element not found: ' + ref + '. Take a snapshot to get updated refs.'
							};
						}

						if (scrollIntoView) {
							const scrollableAncestors = getScrollableAncestors(element);
							let scrolledContainers = 0;

							for (const container of scrollableAncestors) {
								if (!isElementVisibleInContainer(element, container)) {
									scrollElementIntoContainer(element, container);
									scrolledContainers++;
									await new Promise(r => setTimeout(r, 100));
								}
							}

							element.scrollIntoView({ behavior: 'smooth', block: 'center', inline: 'center' });
							await new Promise(r => setTimeout(r, 200));

							const finalRect = element.getBoundingClientRect();
							const isVisible = finalRect.top >= 0 && finalRect.bottom <= window.innerHeight &&
								finalRect.left >= 0 && finalRect.right <= window.innerWidth;

							return {
								success: true,
								action: 'scrollIntoView',
								ref: ref,
								scrolledContainers: scrolledContainers,
								isNowVisible: isVisible,
								message: 'Scrolled element into view' + (scrolledContainers > 0 ? ' (scrolled ' + scrolledContainers + ' nested container(s))' : '') + (isVisible ? '' : ' (element may still be partially obscured)')
							};
						} else {
							const scrollableParent = getScrollableAncestors(element)[0];

							if (scrollableParent) {
								const beforeX = scrollableParent.scrollLeft;
								const beforeY = scrollableParent.scrollTop;
								scrollableParent.scrollBy({ left: deltaX, top: deltaY, behavior: 'smooth' });
								await new Promise(r => setTimeout(r, 200));
								const actualDeltaX = scrollableParent.scrollLeft - beforeX;
								const actualDeltaY = scrollableParent.scrollTop - beforeY;

								const containerRef = scrollableParent.getAttribute('data-cursor-ref');
								return {
									success: true,
									action: 'scrollContainer',
									ref: ref,
									containerRef: containerRef || undefined,
									scrolled: { deltaX: actualDeltaX, deltaY: actualDeltaY },
									message: 'Scrolled container by (' + actualDeltaX + ', ' + actualDeltaY + ') pixels'
								};
							} else {
								return {
									success: false,
									error: 'Element ' + ref + ' is not inside a scrollable container.',
									suggestion: 'Use scrollIntoView: true to scroll the element into view using the standard scrollIntoView method, or omit the ref to scroll the main page.'
								};
							}
						}
					} else {
						const beforeX = window.scrollX;
						const beforeY = window.scrollY;
						window.scrollBy({ left: deltaX, top: deltaY, behavior: 'smooth' });
						await new Promise(r => setTimeout(r, 200));
						const actualDeltaX = window.scrollX - beforeX;
						const actualDeltaY = window.scrollY - beforeY;

						if (actualDeltaX === 0 && actualDeltaY === 0 && (deltaX !== 0 || deltaY !== 0)) {
							return {
								success: true,
								action: 'scroll',
								warning: 'Page may have reached scroll boundary',
								message: 'Attempted to scroll page, but no scroll occurred (may be at edge)'
							};
						}

						return {
							success: true,
							action: 'scroll',
							scrolled: { deltaX: actualDeltaX, deltaY: actualDeltaY },
							message: 'Scrolled page by (' + actualDeltaX + ', ' + actualDeltaY + ') pixels'
						};
					}
				})();
			

Unknown scroll error

### Action: scroll

- ${c.message}

- Actual scroll: (${c.scrolled.deltaX}px, ${c.scrolled.deltaY}px)

- Warning: ${c.warning}

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

					${q}
					(function() {
						const ref = ${JSON.stringify(r)};
						const expectedDescription = ${JSON.stringify(o)};
						const { element } = findElementByRef(ref);
						if (!element) {
							return { success: false, error: 'Element not found: ' + ref + '. Take a snapshot to get updated refs.' };
						}
						assertDescriptionMatches(element, ref, expectedDescription);
						const rect = element.getBoundingClientRect();
						const x = rect.left + window.scrollX;
						const y = rect.top + window.scrollY;
						return {
							success: true,
							box: {
								x,
								y,
								width: rect.width,
								height: rect.height,
								top: rect.top,
								left: rect.left,
								right: rect.right,
								bottom: rect.bottom
							}
						};
					})();
				

Bounding box: x=${Math.round(i.x)}, y=${Math.round(i.y)}, w=${Math.round(i.width)}, h=${Math.round(i.height)}

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

					${q}
					(function() {
						const ref = ${JSON.stringify(r)};
						const expectedDescription = ${JSON.stringify(o)};
						const durationMs = ${s};
						const { element } = findElementByRef(ref);
						if (!element) {
							return { success: false, error: 'Element not found: ' + ref + '. Take a snapshot to get updated refs.' };
						}
						assertDescriptionMatches(element, ref, expectedDescription);

						const styleId = 'cursor-highlight-style';
						if (!document.getElementById(styleId)) {
							const style = document.createElement('style');
							style.id = styleId;
							style.textContent = '.cursor-highlighted { outline: 2px solid #ff6a00; box-shadow: 0 0 0 2px rgba(255, 106, 0, 0.4); }';
							document.head.appendChild(style);
						}

						element.classList.add('cursor-highlighted');
						setTimeout(() => {
							element.classList.remove('cursor-highlighted');
						}, durationMs);

						return { success: true, durationMs };
					})();
				

Highlighted element for ${nt(await et(i,n,t.headless,e),["durationMs"]).durationMs}ms

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

Browser unlocked.

Browser locked.

Failed to unlock browser.

Failed to lock browser.

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

					${q}
					${c}
					${dt}
					(async function() {
						const ref = ${JSON.stringify(r)};
						const expectedDescription = ${JSON.stringify(o)};
						const { element } = findElementByRef(ref);
						validateElementForInteraction(element, ref, 'type', expectedDescription);

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

						const tagName = element.tagName.toUpperCase();
						const isContentEditable = element.isContentEditable;

						const valueBefore = isContentEditable ? element.textContent : element.value;

						const previousActiveElement = document.activeElement;
						if (previousActiveElement && previousActiveElement !== element && previousActiveElement !== document.body) {
							if (typeof previousActiveElement.blur === 'function') {
								previousActiveElement.blur();
							}
						}

						element.focus();

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

						if (document.activeElement !== element) {
							element.click();
							element.focus();
							await new Promise(r => setTimeout(r, 0));
						}

						if (document.activeElement !== element) {
							const elementTag = element.tagName?.toLowerCase() || 'element';
							const focusBlockers = [];

							const style = window.getComputedStyle(element);
							if (element.tabIndex < 0) focusBlockers.push('negative tabindex');
							if (style.display === 'none') focusBlockers.push('display: none');
							if (style.visibility === 'hidden') focusBlockers.push('visibility: hidden');
							if (element.disabled) focusBlockers.push('disabled attribute');

							const hitCheck = document.elementFromPoint(
								rect.left + rect.width / 2,
								rect.top + rect.height / 2
							);
							if (hitCheck && hitCheck !== element && !element.contains(hitCheck)) {
								const hitPreview = hitCheck.tagName?.toLowerCase() + (hitCheck.getAttribute('data-cursor-ref') ? ' (ref: ' + hitCheck.getAttribute('data-cursor-ref') + ')' : '');
								focusBlockers.push('another element at position: ' + hitPreview);
							}

							const reason = focusBlockers.length > 0
								? ' Possible reasons: ' + focusBlockers.join(', ') + '.'
								: ' The element may not be focusable, or another element may be intercepting focus.';
							throw new Error('Failed to focus ' + elementTag + ' ' + ref + '.' + reason + ' Try taking a fresh snapshot to verify the element state.');
						}

						const text = ${JSON.stringify(t.text)};
						const clearFirst = ${JSON.stringify(t.clear)} || false;
						const slowly = ${JSON.stringify(t.slowly)} || false;
						const submit = ${JSON.stringify(t.submit)} || false;

						function dispatchInputEvent(el) {
							const inputEvent = new InputEvent('input', { bubbles: true, cancelable: true, inputType: 'insertText', data: text });
							el.dispatchEvent(inputEvent);
						}

						if (clearFirst) {
							if (isContentEditable) {
								element.textContent = '';
							} else {
								setNativeValue(element, '');
							}
							element.dispatchEvent(new Event('input', { bubbles: true }));
						}

						if (slowly) {
							const delay = 50;
							const existingValue = clearFirst ? '' : (isContentEditable ? (element.textContent || '') : (element.value || ''));
							for (let i = 0; i < text.length; i++) {
								const char = text[i];
								if (isContentEditable) {
									const selection = window.getSelection();
									const range = document.createRange();
									range.selectNodeContents(element);
									range.collapse(false);
									selection.removeAllRanges();
									selection.addRange(range);
									document.execCommand('insertText', false, char);
								} else {
									setNativeValue(element, existingValue + text.substring(0, i + 1));
								}
								element.dispatchEvent(new KeyboardEvent('keydown', { key: char, bubbles: true, cancelable: true }));
								dispatchInputEvent(element);
								element.dispatchEvent(new KeyboardEvent('keyup', { key: char, bubbles: true, cancelable: true }));
								await new Promise(r => setTimeout(r, delay));
							}
						} else {
							if (isContentEditable) {
								const existingContent = clearFirst ? '' : (element.textContent || '');
								element.textContent = existingContent + text;
								element.dispatchEvent(new Event('input', { bubbles: true }));
							} else {
								const existingValue = clearFirst ? '' : (element.value || '');
								setNativeValue(element, existingValue + text);
								dispatchInputEvent(element);
							}
						}

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

						if (submit) {
							element.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', keyCode: 13, code: 'Enter', which: 13, bubbles: true, cancelable: true }));
							element.dispatchEvent(new KeyboardEvent('keypress', { key: 'Enter', keyCode: 13, code: 'Enter', which: 13, bubbles: true, cancelable: true }));
							element.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', keyCode: 13, code: 'Enter', which: 13, bubbles: true, cancelable: true }));
						}

						const valueAfter = isContentEditable ? element.textContent : element.value;
						const valueChanged = valueBefore !== valueAfter;
						const valueMatchesExpected = isContentEditable
							? (element.textContent || '').includes(text)
							: element.value === text || element.value.endsWith(text);

						const maxLength = element.maxLength;
						const hasMaxLength = maxLength > 0 && maxLength !== 2147483647;
						const exceedsMaxLength = hasMaxLength && (valueAfter?.length || 0) > maxLength;

						const snapshotResult = buildPageSnapshot();
						return {
							success: true,
							slowly,
							submitted: submit,
							textLength: text.length,
							valueChanged,
							valueMatchesExpected,
							actualValue: valueAfter ? String(valueAfter).substring(0, 100) : '',
							maxLength: hasMaxLength ? maxLength : null,
							exceedsMaxLength,
							pageState: {
								url: window.location.href,
								title: document.title,
								snapshot: snapshotResult.tree
							}
						};
					})();
				

- Characters typed: ${i.textLength}

- Typing mode: 

slow (character-by-character)

- Cleared existing content: yes

- Form submitted: yes (Enter key pressed)

- WARNING: Value did not change after typing

- Note: Final value differs from input (actual: "${i.actualValue}")

- Note: Input exceeds maxlength attribute (${i.maxLength}). Browser automation bypasses maxlength validation. Server-side validation may still reject this value.

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

					${q}
					${c}
					${dt}
					(async function() {
						const ref = ${JSON.stringify(r)};
						const expectedDescription = ${JSON.stringify(o)};
						const { element } = findElementByRef(ref);
						validateElementForInteraction(element, ref, 'fill', expectedDescription);

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

						const tagName = element.tagName.toUpperCase();
						const isContentEditable = element.isContentEditable;

						const previousActiveElement = document.activeElement;
						if (previousActiveElement && previousActiveElement !== element && previousActiveElement !== document.body) {
							if (typeof previousActiveElement.blur === 'function') {
								previousActiveElement.blur();
							}
						}

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

						if (document.activeElement !== element) {
							element.click();
							element.focus();
							await new Promise(r => setTimeout(r, 0));
						}

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

						if (isContentEditable) {
							element.textContent = '';
							element.textContent = value;
						} else {
							setNativeValue(element, '');
							setNativeValue(element, value);
						}

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

						const snapshotResult = buildPageSnapshot();
						return {
							success: true,
							value: value,
							pageState: {
								url: window.location.href,
								title: document.title,
								snapshot: snapshotResult.tree
							}
						};
					})();
				

- Filled with value: "${i.value.substring(0,50)}${i.value.length>50?"...":""}"

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

Error: Missing required "fields" parameter.

The browser_fill_form tool requires a "fields" array containing the fields to fill.

Example usage:
{ fields: [{ ref: "e123", value: "John Doe" }, { ref: "e456", value: "john@example.com" }] }

Each field should have a "ref" (element reference) and "value" (text to fill).

Error: Empty "fields" array provided.

Provide at least one field to fill. Take a snapshot to identify the form fields and their refs.

					${q}
					${c}
					${dt}
					(async function() {
						const fields = ${JSON.stringify(r)};
						const filled = [];
						const failed = [];

						for (const field of fields) {
							const ref = field.ref;
							const expectedDescription = field.element || '';
							try {
								const { element } = findElementByRef(ref);
								validateElementForInteraction(element, ref, 'fill', expectedDescription);

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

								const isContentEditable = element.isContentEditable;
								const clearFirst = field.clear !== undefined ? field.clear : true;
								const value = String(field.value);

								if (clearFirst) {
									if (isContentEditable) {
										element.textContent = '';
									} else {
										setNativeValue(element, '');
									}
								}

								if (isContentEditable) {
									const existingContent = clearFirst ? '' : (element.textContent || '');
									element.textContent = existingContent + value;
								} else {
									const existingValue = clearFirst ? '' : (element.value || '');
									setNativeValue(element, existingValue + value);
								}

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

								const preview = value.length > 60 ? value.substring(0, 60) + '...' : value;
								filled.push({ ref, valuePreview: preview });
							} catch (err) {
								const message = err instanceof Error ? err.message : String(err);
								failed.push({ ref, error: message });
							}
						}

						const snapshotResult = buildPageSnapshot();
						return {
							success: failed.length === 0,
							filled,
							failed,
							pageState: {
								url: window.location.href,
								title: document.title,
								snapshot: snapshotResult.tree
							}
						};
					})();
				

- Fields filled: ${s.filled.length}

- Fields failed: ${s.failed.length}

${t.ref}: ${t.error}