extension.js · part 5

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

File contents and all parts · All files

Error: x and y must be finite numbers.

Use coordinates from a fresh viewport screenshot.

(${o}, ${s})

No browser tab available

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

No recent viewport screenshot available

Error: browser_mouse_click_xy needs a fresh screenshot for this tab.

Take a screenshot right before this call. Other browser tool calls clear the cache.

			${q}
			${c}
			${ut}
			(async function() {
				const screenshotX = ${o};
				const screenshotY = ${s};
				const mappedX = ${d.mappedX};
				const mappedY = ${d.mappedY};
				const cachedUrl = ${JSON.stringify(l.url)};
				const sentImageWidth = ${l.sentImageWidth};
				const sentImageHeight = ${l.sentImageHeight};

				if (window.location.href !== cachedUrl) {
					const snapshotResult = buildPageSnapshot();
					return {
						success: false,
						staleScreenshot: true,
						error: 'browser_mouse_click_xy needs a fresh screenshot. The page changed since the last one.',
						suggestion: 'Take a new screenshot for this tab, then retry with coordinates from it.',
						pageState: {
							url: window.location.href,
							title: document.title,
							snapshot: snapshotResult.tree
						}
					};
				}

				const targetElement = getDeepElementFromPoint(document, mappedX, mappedY);

				if (!targetElement) {
					const snapshotResult = buildPageSnapshot();
					return {
						success: false,
						error: 'The coordinates are outside the visible viewport.',
						suggestion: 'Take a new screenshot for this tab, then retry with coordinates from it.',
						screenshotCoordinates: { x: screenshotX, y: screenshotY },
						mappedCoordinates: { x: mappedX, y: mappedY },
						screenshotSize: { width: sentImageWidth, height: sentImageHeight },
						pageState: {
							url: window.location.href,
							title: document.title,
							snapshot: snapshotResult.tree
						}
					};
				}

				await dispatchMouseClickSequenceInBrowser(targetElement, {
					x: mappedX,
					y: mappedY,
					button: ${JSON.stringify(t.button??"left")}
				});

				const snapshotResult = buildPageSnapshot();
				return {
					success: true,
					button: ${JSON.stringify(t.button??"left")},
					screenshotCoordinates: { x: screenshotX, y: screenshotY },
					mappedCoordinates: { x: mappedX, y: mappedY },
					screenshotSize: { width: sentImageWidth, height: sentImageHeight },
					targetPreview: previewNode(targetElement),
					targetRef: targetElement.getAttribute ? (targetElement.getAttribute('data-cursor-ref') || undefined) : undefined,
					pageState: {
						url: window.location.href,
						title: document.title,
						snapshot: snapshotResult.tree
					}
				};
			})();
		

Error: ${p.error||`Failed to click at coordinates (${o}, ${s}).`}

Failed to click at coordinates (${o}, ${s}).

- Screenshot position: (${p.screenshotCoordinates.x}, ${p.screenshotCoordinates.y})

- Mapped viewport position: (${p.mappedCoordinates.x}, ${p.mappedCoordinates.y})

- Screenshot size: ${p.screenshotSize.width}x${p.screenshotSize.height}

Suggestion: ${p.suggestion}

${r} (failed)

- Screenshot position: (${o}, ${s})

- Viewport position: (${d.mappedX}, ${d.mappedY})

- Target: ${p.targetPreview}

- Target ref: ${p.targetRef}

${i} -> (${d.mappedX}, ${d.mappedY})

(${o}, ${s})

No browser tab available

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

			${q}
			${c}
			${pt}
			
const HOVER_WAIT_INTERVALS = [100, 200, 300];

const DEFAULT_HOVER_SELECTORS = [
	'[role="tooltip"]',
	'[role="menu"]',
	'[role="listbox"]',
	'.tooltip',
	'.dropdown-menu',
	'.popover',
	'.submenu',
	'[data-tooltip]',
	'[aria-describedby]',
	'[data-state="open"]',
	'[data-radix-popper-content-wrapper]'
];

function isElementVisibleAndSized(el) {
	if (!el) return false;
	const style = window.getComputedStyle(el);
	if (style.display === 'none' || style.visibility === 'hidden' || parseFloat(style.opacity) === 0) {
		return false;
	}
	const rect = el.getBoundingClientRect();
	return rect.width > 0 && rect.height > 0;
}

function findNewlyVisibleElements(selectors, previouslyFound) {
	const found = [];
	for (const selector of selectors) {
		try {
			const elements = document.querySelectorAll(selector);
			for (const el of elements) {
				if (isElementVisibleAndSized(el)) {
					const ref = el.getAttribute('data-cursor-ref');
					const role = el.getAttribute('role') || '';
					const tag = el.tagName?.toLowerCase() || '';
					const classes = el.className && typeof el.className === 'string'
						? el.className.trim().split(/\s+/).slice(0, 2).join(' ')
						: '';
					const desc = '<' + tag + (role ? ' role="' + role + '"' : '') + (ref ? ' ref="' + ref + '"' : '') + (classes ? ' class="' + classes + '"' : '') + '>';
					if (!previouslyFound.has(desc)) {
						found.push({ desc, ref, tag, role });
						previouslyFound.add(desc);
					}
				}
			}
		} catch (e) {}
	}
	return found;
}

async function verifyHoverContentAsync(options) {
	const waitIntervals = HOVER_WAIT_INTERVALS;
	const maxChecks = options.maxChecks || 3;
	const selectors = options.selectors && options.selectors.length > 0
		? options.selectors
		: DEFAULT_HOVER_SELECTORS;
	const textPatterns = options.textPatterns || [];

	const result = {
		verified: false,
		checksPassed: 0,
		totalChecks: maxChecks,
		foundElements: [],
		waitIntervals: [],
		totalWaitMs: 0,
		snapshotsChecked: 0
	};

	const previouslyFound = new Set();

	for (let i = 0; i < maxChecks; i++) {
		const waitMs = waitIntervals[i] || waitIntervals[waitIntervals.length - 1];
		result.waitIntervals.push(waitMs);
		result.totalWaitMs += waitMs;

		await new Promise(r => setTimeout(r, waitMs));
		result.checksPassed++;
		result.snapshotsChecked++;

		const newElements = findNewlyVisibleElements(selectors, previouslyFound);
		for (const el of newElements) {
			result.foundElements.push(el.desc);
			result.verified = true;
		}

		if (textPatterns.length > 0) {
			const bodyText = document.body.innerText || '';
			for (const pattern of textPatterns) {
				const patternKey = 'text: "' + pattern.substring(0, 30) + '"';
				if (bodyText.includes(pattern) && !previouslyFound.has(patternKey)) {
					result.verified = true;
					result.foundElements.push(patternKey);
					previouslyFound.add(patternKey);
				}
			}
		}

		if (result.verified) {
			break;
		}
	}

	return result;
}

			(async function() {
				const ref = ${JSON.stringify(s)};
				const expectedDescription = ${JSON.stringify(i)};
				const maxWaitMs = ${a};
				const pollIntervalMs = ${l};
				const waitForSelector = ${JSON.stringify(d)};
				const waitForText = ${JSON.stringify(u)};
				const useFullSnapshot = ${p};
				const shouldVerifyHover = ${f};

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

				try {
					validateElementForInteraction(element, ref, 'hover', expectedDescription);
				} catch (e) {
					return { success: false, error: e.message };
				}

				const scrollResult = await ensureElementInView(element, 3);
				if (!scrollResult.success) {
					return {
						success: false,
						error: 'Could not scroll element into view.'
					};
				}

				const rect = element.getBoundingClientRect();
				const cx = Math.round(rect.left + rect.width / 2);
				const cy = Math.round(rect.top + rect.height / 2);

				const hitCheck = expectHitTarget({ x: cx, y: cy }, element, ref);
				if (!hitCheck.hit) {
					return {
						success: false,
						hitTargetFailed: true,
						error: hitCheck.error || 'Hover would not reach the intended element.',
						interceptedBy: hitCheck.interceptedBy,
						interceptedRef: hitCheck.interceptedRef,
						suggestion: hitCheck.suggestion
					};
				}

				const eventOptions = {
					bubbles: true,
					cancelable: true,
					view: window,
					clientX: cx,
					clientY: cy,
					pointerId: 1,
					pointerType: 'mouse',
					isPrimary: true
				};

				element.dispatchEvent(new PointerEvent('pointerover', eventOptions));
				element.dispatchEvent(new PointerEvent('pointerenter', { ...eventOptions, bubbles: false }));
				element.dispatchEvent(new MouseEvent('mouseover', eventOptions));
				element.dispatchEvent(new MouseEvent('mouseenter', { ...eventOptions, bubbles: false }));
				element.dispatchEvent(new PointerEvent('pointermove', eventOptions));
				element.dispatchEvent(new MouseEvent('mousemove', eventOptions));

				let waitedMs = 0;
				let foundTarget = false;
				let waitIterations = 0;
				let verificationResult = null;

				if (shouldVerifyHover) {
					const intervals = HOVER_WAIT_INTERVALS;
					let totalMs = 0;
					let checksNeeded = 0;
					for (let i = 0; totalMs < maxWaitMs; i++) {
						const interval = intervals[Math.min(i, intervals.length - 1)];
						totalMs += interval;
						checksNeeded++;
					}
					checksNeeded = Math.max(checksNeeded, 1);

					const verifyOptions = {
						maxChecks: checksNeeded,
						selectors: waitForSelector ? [waitForSelector] : undefined,
						textPatterns: waitForText ? [waitForText] : undefined
					};
					verificationResult = await verifyHoverContentAsync(verifyOptions);
					foundTarget = verificationResult.verified;
					waitedMs = verificationResult.totalWaitMs;
					waitIterations = verificationResult.checksPassed;
				} else if (waitForSelector || waitForText) {
					const startTime = Date.now();

					while (waitedMs < maxWaitMs) {
						waitIterations++;

						if (waitForSelector) {
							const target = document.querySelector(waitForSelector);
							if (target) {
								const style = window.getComputedStyle(target);
								if (style.display !== 'none' && style.visibility !== 'hidden' && parseFloat(style.opacity) > 0) {
									foundTarget = true;
									break;
								}
							}
						}

						if (waitForText) {
							const bodyText = document.body.innerText || '';
							if (bodyText.includes(waitForText)) {
								foundTarget = true;
								break;
							}
						}

						const currentInterval = Math.min(pollIntervalMs * Math.pow(1.5, waitIterations - 1), 500);
						await new Promise(r => setTimeout(r, currentInterval));
						waitedMs = Date.now() - startTime;
					}
				} else {
					await new Promise(r => setTimeout(r, 100));
					foundTarget = true;
				}

				const snapshotResult = buildPageSnapshot({ compact: !useFullSnapshot });
				return {
					success: true,
					waitedMs,
					waitIterations,
					foundTarget,
					waitCondition: waitForSelector ? 'selector: ' + waitForSelector : (waitForText ? 'text: ' + waitForText : 'none'),
					snapshotMode: useFullSnapshot ? 'full' : 'compact',
					verificationResult: verificationResult,
					pageState: {
						url: window.location.href,
						title: document.title,
						snapshot: snapshotResult.tree
					}
				};
			})();
		

Hover failed

- Hovered over element: ${s}

- Wait condition: ${h.waitCondition}

- Target found: 

- Waited: ${h.waitedMs}ms (${h.waitIterations} iterations)

- Snapshot mode: ${h.snapshotMode}

- Hover verification: 

- Checks: ${h.verificationResult.checksPassed}/${h.verificationResult.totalChecks}

- Found elements: ${h.verificationResult.foundElements.join(", ")}

- Wait intervals: [${h.verificationResult.waitIntervals.join("ms, ")}ms]

Hover content verification failed:

  - Checked ${h.verificationResult.snapshotsChecked||h.verificationResult.checksPassed} snapshots at intervals [100ms, 200ms, 300ms]

  - No tooltip, menu, or submenu elements appeared

  - Snapshot mode used: ${h.snapshotMode||"compact"}

  - Try using fullSnapshot: true for more detailed element detection

  - The hover target may not have hover-triggered content

  - Check if the element requires a longer hover duration

Hover content not detected after verification

Navigating to ${e.url}${e.headless?" (headless)":""}

Creating headless tab with viewId: ${e.viewId}

Failed to create headless browser tab

Browser view not found: ${e.viewId}. Use browser_navigate without a viewId to create a new tab.

Navigate to viewId ${e.viewId} failed, creating a new tab: ${t instanceof Error?t.message:String(t)}

Reuse of tab ${r} failed, creating a new tab: ${t instanceof Error?t.message:String(t)}

Failed to create headless browser tab

Failed to create new browser tab

Open tabs:
(none)

Open tabs:
${(await Promise.all(t.tabs.map(async(t,e)=>{const[n,o]=await Promise.all([s.commands.executeCommand("cursor.browserView.getURL",t,r),s.commands.executeCommand("cursor.browserView.getTitle",t,r)]);return`[${e}] "${o||"New Tab"}" - ${n||"about:blank"} (viewId: ${t})`}))).join("\n")}

[${e}] "${o||"New Tab"}" - ${n||"about:blank"} (viewId: ${t})

New Tab

Created new tab

 on the side

New Tab

Tab closed. No remaining tabs.

Tab index is required

Tab ${e.index} not found

New Tab