@hypothesi/tauri-mcp-server 0.8.2 → 0.9.0

package/dist/driver/scripts/element-picker.js

@@ -0,0 +1,395 @@
+/**
+ * Element picker overlay for MCP Server Tauri.
+ *
+ * Activated by the agent via webview_select_element. Displays a hover highlight,
+ * context tooltip, and cancel bar. On click (desktop) or two-tap (mobile) the
+ * selected element's metadata is emitted as a Tauri event so the MCP server can
+ * retrieve it asynchronously.
+ *
+ * @param {Object} params
+ * @param {string} params.mode - 'pick' (agent-initiated picker)
+ * @param {string} params.pickerId - Unique identifier for this picker session
+ */
+(function(params) {
+   var mode = params.mode;
+   var pickerId = params.pickerId;
+
+   // Duplicate-activation guard
+   if (window.__MCP_PICKER_ACTIVE__) {
+      // Cancel the previous picker
+      var prevId = window.__MCP_PICKER_ACTIVE__;
+      cleanup();
+      if (window.__TAURI__ && window.__TAURI__.event && window.__TAURI__.event.emit) {
+         window.__TAURI__.event.emit('__element_picked', { pickerId: prevId, cancelled: true });
+      }
+   }
+   window.__MCP_PICKER_ACTIVE__ = pickerId;
+
+   var isTouch = ('ontouchstart' in window) || (navigator.maxTouchPoints > 0);
+   var highlight = null;
+   var tooltip = null;
+   var cancelBar = null;
+   var trackedElement = null; // element currently being highlighted
+   var rafId = null; // requestAnimationFrame handle for cyclic repositioning
+
+   // ── Velocity-based hover throttling state ──────────────────────────────
+   var lastMouseX = 0;
+   var lastMouseY = 0;
+   var lastMouseTime = 0;
+   var mouseVelocity = 0;
+   var hoverUpdateTimer = null;
+
+   // ── Cancel bar ─────────────────────────────────────────────────────────
+   cancelBar = document.createElement('div');
+   cancelBar.setAttribute('data-mcp-picker', 'cancel-bar');
+   var cancelBarAtTop = true;
+   cancelBar.style.cssText =
+      'position:fixed;top:0;left:0;right:0;z-index:2147483647;height:40px;' +
+      'background:rgba(30,41,59,0.95);display:flex;align-items:center;' +
+      'justify-content:space-between;padding:0 12px;font:13px/1 system-ui,sans-serif;' +
+      'color:#E2E8F0;box-sizing:border-box;' +
+      'transition:top 0.2s ease,bottom 0.2s ease;';
+
+   var cancelText = document.createElement('span');
+   cancelText.textContent = 'MCP Element Picker \u2014 Click to select | ESC or tap X to cancel';
+   cancelText.style.cssText = 'overflow:hidden;text-overflow:ellipsis;white-space:nowrap;flex:1;';
+
+   // Move button — toggles bar between top and bottom
+   var moveBtn = document.createElement('button');
+   moveBtn.setAttribute('data-mcp-picker', 'move-btn');
+   moveBtn.textContent = '\u2193'; // ↓
+   moveBtn.title = 'Move bar to bottom';
+   moveBtn.style.cssText =
+      'background:none;border:none;color:#94A3B8;font-size:16px;cursor:pointer;' +
+      'width:32px;height:40px;display:flex;align-items:center;justify-content:center;' +
+      'flex-shrink:0;';
+   function toggleCancelBarPosition(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      cancelBarAtTop = !cancelBarAtTop;
+      cancelBar.style.top = cancelBarAtTop ? '0' : 'auto';
+      cancelBar.style.bottom = cancelBarAtTop ? 'auto' : '0';
+      moveBtn.textContent = cancelBarAtTop ? '\u2193' : '\u2191'; // ↓ or ↑
+      moveBtn.title = cancelBarAtTop ? 'Move bar to bottom' : 'Move bar to top';
+   }
+   moveBtn.addEventListener('click', toggleCancelBarPosition);
+   moveBtn.addEventListener('touchend', toggleCancelBarPosition);
+
+   var cancelBtn = document.createElement('button');
+   cancelBtn.setAttribute('data-mcp-picker', 'cancel-btn');
+   cancelBtn.textContent = '\u2715';
+   cancelBtn.style.cssText =
+      'background:none;border:none;color:#E2E8F0;font-size:20px;cursor:pointer;' +
+      'width:40px;height:40px;display:flex;align-items:center;justify-content:center;' +
+      'flex-shrink:0;';
+   cancelBtn.addEventListener('click', function(e) {
+      e.stopPropagation();
+      cancelPicker();
+   });
+   cancelBtn.addEventListener('touchend', function(e) {
+      e.stopPropagation();
+      e.preventDefault();
+      cancelPicker();
+   });
+
+   cancelBar.appendChild(cancelText);
+   cancelBar.appendChild(moveBtn);
+   cancelBar.appendChild(cancelBtn);
+   document.body.appendChild(cancelBar);
+
+   // ── Highlight helpers ──────────────────────────────────────────────────
+   function createHighlight() {
+      var el = document.createElement('div');
+      el.setAttribute('data-mcp-picker', 'highlight');
+      el.style.cssText =
+         'position:fixed;z-index:2147483645;pointer-events:none;' +
+         'background:rgba(59,130,246,0.15);border:2px solid #3B82F6;';
+      document.body.appendChild(el);
+      return el;
+   }
+
+   function positionHighlight(el, target) {
+      var rect = target.getBoundingClientRect();
+      el.style.top = rect.top + 'px';
+      el.style.left = rect.left + 'px';
+      el.style.width = rect.width + 'px';
+      el.style.height = rect.height + 'px';
+   }
+
+   // ── Cyclic highlight repositioning via rAF ─────────────────────────────
+   // Keeps the highlight tracking animated or repositioned elements at ~60fps.
+   function startTracking() {
+      if (rafId) return;
+      function tick() {
+         if (trackedElement && highlight) {
+            positionHighlight(highlight, trackedElement);
+         }
+         rafId = requestAnimationFrame(tick);
+      }
+      rafId = requestAnimationFrame(tick);
+   }
+
+   function stopTracking() {
+      if (rafId) {
+         cancelAnimationFrame(rafId);
+         rafId = null;
+      }
+   }
+
+   // ── Tooltip helpers ────────────────────────────────────────────────────
+   function showTooltip(target) {
+      if (!tooltip) {
+         tooltip = document.createElement('div');
+         tooltip.setAttribute('data-mcp-picker', 'tooltip');
+         tooltip.style.cssText =
+            'position:fixed;z-index:2147483646;pointer-events:none;' +
+            'background:#1E293B;color:#E2E8F0;font:12px/1.4 monospace;' +
+            'padding:4px 8px;border-radius:4px;white-space:nowrap;max-width:300px;' +
+            'overflow:hidden;text-overflow:ellipsis;';
+         document.body.appendChild(tooltip);
+      }
+
+      var rect = target.getBoundingClientRect();
+      var tag = target.tagName.toLowerCase();
+      var id = target.id ? '#' + target.id : '';
+      var cls = target.className && typeof target.className === 'string'
+         ? '.' + target.className.trim().split(/\s+/).join('.')
+         : '';
+      var label = (tag + id + cls);
+      if (label.length > 60) label = label.substring(0, 57) + '...';
+      label += ' (' + Math.round(rect.width) + '\u00d7' + Math.round(rect.height) + ')';
+      tooltip.textContent = label;
+
+      // Position above or below the element
+      var tooltipTop = rect.top - 28;
+      if (tooltipTop < 44) { // below the cancel bar (40px + 4px padding)
+         tooltipTop = rect.bottom + 4;
+      }
+      tooltip.style.top = tooltipTop + 'px';
+      tooltip.style.left = Math.max(4, rect.left) + 'px';
+   }
+
+   function hideTooltip() {
+      if (tooltip && tooltip.parentNode) {
+         tooltip.parentNode.removeChild(tooltip);
+         tooltip = null;
+      }
+   }
+
+   // ── Element detection ──────────────────────────────────────────────────
+   // Uses the shared elementsFromPoint helper from bridge.js when available,
+   // falls back to document.elementFromPoint.
+   function findElementAt(x, y) {
+      if (window.__MCP_GET_ELEMENT_AT_POINT__) {
+         return window.__MCP_GET_ELEMENT_AT_POINT__(x, y);
+      }
+      // Fallback: hide highlight, use single elementFromPoint
+      if (highlight) highlight.style.display = 'none';
+      var el = document.elementFromPoint(x, y);
+      if (highlight) highlight.style.display = '';
+      return el;
+   }
+
+   // ── Picker element detection guard (fallback for findElementAt) ────────
+   function isPickerUI(el) {
+      while (el) {
+         if (el.getAttribute && el.getAttribute('data-mcp-picker')) {
+            return true;
+         }
+         el = el.parentElement;
+      }
+      return false;
+   }
+
+   // ── Selection ──────────────────────────────────────────────────────────
+   function selectElement(target) {
+      var metadata;
+      if (window.__MCP_COLLECT_ELEMENT_METADATA__) {
+         metadata = window.__MCP_COLLECT_ELEMENT_METADATA__(target);
+      } else {
+         metadata = { tag: target.tagName.toLowerCase(), cssSelector: '' };
+      }
+
+      // Store in window for later retrieval
+      window.__MCP_PICKED_ELEMENT__ = metadata;
+
+      // Remove overlay + tooltip but keep highlight for screenshot
+      removeCancelBar();
+      hideTooltip();
+      stopTracking();
+      removeListeners();
+
+      // Emit Tauri event
+      if (window.__TAURI__ && window.__TAURI__.event && window.__TAURI__.event.emit) {
+         window.__TAURI__.event.emit('__element_picked', { pickerId: pickerId, element: metadata });
+      }
+
+      window.__MCP_PICKER_ACTIVE__ = null;
+      return 'Element selected: ' + metadata.tag + (metadata.id ? '#' + metadata.id : '');
+   }
+
+   // ── Cancellation ──────────────────────────────────────────────────────
+   function cancelPicker() {
+      cleanup();
+      if (window.__TAURI__ && window.__TAURI__.event && window.__TAURI__.event.emit) {
+         window.__TAURI__.event.emit('__element_picked', { pickerId: pickerId, cancelled: true });
+      }
+      window.__MCP_PICKER_ACTIVE__ = null;
+   }
+
+   // ── Cleanup ────────────────────────────────────────────────────────────
+   function removeCancelBar() {
+      if (cancelBar && cancelBar.parentNode) {
+         cancelBar.parentNode.removeChild(cancelBar);
+         cancelBar = null;
+      }
+   }
+
+   function removeHighlight() {
+      if (highlight && highlight.parentNode) {
+         highlight.parentNode.removeChild(highlight);
+         highlight = null;
+      }
+   }
+
+   function cleanup() {
+      removeCancelBar();
+      removeHighlight();
+      hideTooltip();
+      stopTracking();
+      removeListeners();
+      trackedElement = null;
+      if (hoverUpdateTimer) {
+         clearTimeout(hoverUpdateTimer);
+         hoverUpdateTimer = null;
+      }
+      window.__MCP_PICKER_ACTIVE__ = null;
+   }
+
+   // ── Core hover-update logic (shared by throttled and immediate paths) ──
+   function updateHoveredElement() {
+      var el = findElementAt(lastMouseX, lastMouseY);
+
+      if (!el || isPickerUI(el)) return;
+
+      if (el === trackedElement) return; // no change
+      trackedElement = el;
+
+      if (!highlight) {
+         highlight = createHighlight();
+         startTracking();
+      }
+      positionHighlight(highlight, el);
+      showTooltip(el);
+   }
+
+   // ── Desktop: hover + click with velocity throttling ────────────────────
+   function onMouseMove(e) {
+      var now = performance.now();
+      var dx = e.clientX - lastMouseX;
+      var dy = e.clientY - lastMouseY;
+      var dt = now - lastMouseTime;
+      var distance = Math.sqrt(dx * dx + dy * dy);
+
+      lastMouseX = e.clientX;
+      lastMouseY = e.clientY;
+
+      // Calculate velocity in pixels per second
+      mouseVelocity = dt > 0 ? (distance / dt) * 1000 : 0;
+      lastMouseTime = now;
+
+      // If moving fast (>600 px/s), throttle updates to ~28fps
+      if (mouseVelocity > 600) {
+         if (hoverUpdateTimer) {
+            clearTimeout(hoverUpdateTimer);
+         }
+         hoverUpdateTimer = setTimeout(updateHoveredElement, 36); // ~28fps
+      } else {
+         if (hoverUpdateTimer) {
+            clearTimeout(hoverUpdateTimer);
+            hoverUpdateTimer = null;
+         }
+         updateHoveredElement();
+      }
+   }
+
+   function onClick(e) {
+      // Let clicks on picker UI (cancel, move buttons) pass through to their handlers
+      if (isPickerUI(e.target)) return;
+
+      e.preventDefault();
+      e.stopPropagation();
+
+      var el = findElementAt(e.clientX, e.clientY);
+
+      if (!el || isPickerUI(el)) return;
+
+      selectElement(el);
+   }
+
+   // ── Mobile: two-tap ────────────────────────────────────────────────────
+   var lastTapTarget = null;
+
+   function onTouchEnd(e) {
+      var touch = e.changedTouches[0];
+      if (!touch) return;
+
+      var el = findElementAt(touch.clientX, touch.clientY);
+
+      // Let taps on picker UI (cancel, move buttons) pass through to their handlers
+      if (!el || isPickerUI(el)) return;
+
+      e.preventDefault();
+      e.stopPropagation();
+
+      if (lastTapTarget === el) {
+         // Second tap on same element -> confirm
+         selectElement(el);
+      } else {
+         // First tap (or different element) -> highlight
+         lastTapTarget = el;
+         trackedElement = el;
+
+         if (!highlight) {
+            highlight = createHighlight();
+            startTracking();
+         }
+         positionHighlight(highlight, el);
+         showTooltip(el);
+
+         if (cancelText) {
+            cancelText.textContent = 'Tap element again to send | X Cancel';
+         }
+      }
+   }
+
+   // ── Keyboard escape ────────────────────────────────────────────────────
+   function onKeyDown(e) {
+      if (e.key === 'Escape') {
+         e.preventDefault();
+         e.stopPropagation();
+         cancelPicker();
+      }
+   }
+
+   // ── Listener management ────────────────────────────────────────────────
+   function removeListeners() {
+      document.removeEventListener('mousemove', onMouseMove, true);
+      document.removeEventListener('click', onClick, true);
+      document.removeEventListener('touchend', onTouchEnd, true);
+      document.removeEventListener('keydown', onKeyDown, true);
+   }
+
+   // Attach appropriate listeners based on device
+   document.addEventListener('keydown', onKeyDown, true);
+
+   if (isTouch) {
+      document.addEventListener('touchend', onTouchEnd, true);
+   }
+
+   // Always attach mouse listeners (hybrid devices like touch laptops)
+   document.addEventListener('mousemove', onMouseMove, true);
+   document.addEventListener('click', onClick, true);
+
+   return 'Picker activated (id: ' + pickerId + ')';
+})

package/dist/driver/scripts/find-element.js

@@ -7,36 +7,8 @@
  */
 (function(params) {
    const { selector, strategy } = params;
-   let element;
 
-   // Check if it's a ref ID first (works with any strategy)
-   if (/^\[?(?:ref=)?(e\d+)\]?$/.test(selector)) {
-      element = window.__MCP__.resolveRef(selector);
-   } else if (strategy === 'text') {
-      // Find element containing text
-      const xpath = "//*[contains(text(), '" + selector + "')]";
-      const result = document.evaluate(
-         xpath,
-         document,
-         null,
-         XPathResult.FIRST_ORDERED_NODE_TYPE,
-         null
-      );
-      element = result.singleNodeValue;
-   } else if (strategy === 'xpath') {
-      // XPath selector
-      const result = document.evaluate(
-         selector,
-         document,
-         null,
-         XPathResult.FIRST_ORDERED_NODE_TYPE,
-         null
-      );
-      element = result.singleNodeValue;
-   } else {
-      // CSS selector (default)
-      element = window.__MCP__.resolveRef(selector);
-   }
+   var element = window.__MCP__.resolveRef(selector, strategy);
 
    if (element) {
       const outerHTML = element.outerHTML;
@@ -44,7 +16,10 @@
       const truncated = outerHTML.length > 5000
          ? outerHTML.substring(0, 5000) + '...'
          : outerHTML;
-      return 'Found element: ' + truncated;
+      var msg = 'Found element: ' + truncated;
+      var count = window.__MCP__.countAll(selector, strategy);
+      if (count > 1) msg += '\n(+' + (count - 1) + ' more match' + (count - 1 === 1 ? '' : 'es') + ')';
+      return msg;
    }
 
    return 'Element not found';

package/dist/driver/scripts/focus.js

@@ -2,19 +2,23 @@
  * Focus an element
  *
  * @param {Object} params
- * @param {string} params.selector - CSS selector or ref ID (e.g., "ref=e3") for element to focus
+ * @param {string} params.selector - CSS selector, XPath, text, or ref ID (e.g., "ref=e3") for element to focus
+ * @param {string} params.strategy - Selector strategy: 'css', 'xpath', or 'text'
  */
 (function(params) {
-   const { selector } = params;
+   const { selector, strategy } = params;
 
    function resolveElement(selectorOrRef) {
       if (!selectorOrRef) return null;
-      var el = window.__MCP__.resolveRef(selectorOrRef);
+      var el = window.__MCP__.resolveRef(selectorOrRef, strategy);
       if (!el) throw new Error('Element not found: ' + selectorOrRef);
       return el;
    }
 
    const element = resolveElement(selector);
    element.focus();
-   return `Focused element: ${selector}`;
+   var msg = 'Focused element: ' + selector;
+   var count = window.__MCP__.countAll(selector, strategy);
+   if (count > 1) msg += ' (+' + (count - 1) + ' more match' + (count - 1 === 1 ? '' : 'es') + ')';
+   return msg;
 })

package/dist/driver/scripts/get-styles.js

@@ -2,36 +2,33 @@
  * Get computed CSS styles for elements
  *
  * @param {Object} params
- * @param {string} params.selector - CSS selector or ref ID (e.g., "ref=e3") for element(s)
+ * @param {string} params.selector - CSS selector, XPath, text, or ref ID (e.g., "ref=e3") for element(s)
+ * @param {string} params.strategy - Selector strategy: 'css', 'xpath', or 'text'
  * @param {string[]} params.properties - Specific CSS properties to retrieve
  * @param {boolean} params.multiple - Whether to get styles for all matching elements
  */
 (function(params) {
-   const { selector, properties, multiple } = params;
+   const { selector, strategy, properties, multiple } = params;
 
-   function resolveElement(selectorOrRef) {
-      if (!selectorOrRef) return null;
-      var el = window.__MCP__.resolveRef(selectorOrRef);
-      if (!el) throw new Error('Element not found: ' + selectorOrRef);
-      return el;
-   }
+   var elements;
 
-   // Check if selector is a ref ID - if so, multiple doesn't apply
-   const isRef = /^\[?(?:ref=)?(e\d+)\]?$/.test(selector);
-   const elements = isRef
-      ? [resolveElement(selector)]
-      : (multiple ? Array.from(document.querySelectorAll(selector)) : [document.querySelector(selector)]);
+   if (multiple) {
+      elements = window.__MCP__.resolveAll(selector, strategy);
+   } else {
+      var el = window.__MCP__.resolveRef(selector, strategy);
+      elements = el ? [el] : [];
+   }
 
    if (!elements[0]) {
-      throw new Error(`Element not found: ${selector}`);
+      throw new Error('Element not found: ' + selector);
    }
 
-   const results = elements.map(element => {
+   const results = elements.map(function(element) {
       const styles = window.getComputedStyle(element);
 
       if (properties.length > 0) {
          const result = {};
-         properties.forEach(prop => {
+         properties.forEach(function(prop) {
             result[prop] = styles.getPropertyValue(prop);
          });
          return result;

package/dist/driver/scripts/html2canvas-loader.js

@@ -22,7 +22,11 @@ export function getHtml2CanvasSource() {
         // Resolve the path to html2canvas-pro.js (UMD build)
         // Note: We use the main entry point since the minified version isn't exported
         const html2canvasProPath = require.resolve('html2canvas-pro');
-        html2canvasProSource = readFileSync(html2canvasProPath, 'utf-8');
+        html2canvasProSource = readFileSync(html2canvasProPath, 'utf-8')
+            // Strip sourceMappingURL to prevent the browser from trying to fetch the
+            // .map file relative to the page's base URL (which fails when the app is
+            // served under a sub-path like '/some/path/').
+            .replace(/\/\/[#@]\s*sourceMappingURL=.*/g, '');
     }
     return html2canvasProSource;
 }

package/dist/driver/scripts/index.js

@@ -22,6 +22,7 @@ export const SCRIPTS = {
     focus: loadScript('focus'),
     findElement: loadScript('find-element'),
     domSnapshot: loadScript('dom-snapshot'),
+    elementPicker: loadScript('element-picker'),
 };
 /** Script ID used for resolve-ref in the script registry. */
 export const RESOLVE_REF_SCRIPT_ID = '__mcp_resolve_ref__';
@@ -41,14 +42,17 @@ export function buildScript(script, params) {
 /**
  * Build a script for typing text (uses the keyboard script's typeText function)
  */
-export function buildTypeScript(selector, text) {
+export function buildTypeScript(selector, text, strategy) {
     const escapedText = text.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    const escapedSelector = selector.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    const strat = strategy || 'css';
     return `
       (function() {
-         const selector = '${selector}';
+         const selector = '${escapedSelector}';
+         const strategy = '${strat}';
          const text = '${escapedText}';
 
-         var element = window.__MCP__.resolveRef(selector);
+         var element = window.__MCP__.resolveRef(selector, strategy);
          if (!element) throw new Error('Element not found: ' + selector);
 
          element.focus();
@@ -56,7 +60,10 @@ export function buildTypeScript(selector, text) {
          element.dispatchEvent(new Event('input', { bubbles: true }));
          element.dispatchEvent(new Event('change', { bubbles: true }));
 
-         return 'Typed "' + text + '" into ' + selector;
+         var msg = 'Typed "' + text + '" into ' + selector;
+         var count = window.__MCP__.countAll(selector, strategy);
+         if (count > 1) msg += ' (+' + (count - 1) + ' more match' + (count - 1 === 1 ? '' : 'es') + ')';
+         return msg;
       })()
    `;
 }

package/dist/driver/scripts/interact.js

@@ -4,7 +4,8 @@
  *
  * @param {Object} params
  * @param {string} params.action - The action to perform
- * @param {string|null} params.selector - CSS selector or ref ID (e.g., "ref=e3") for the element
+ * @param {string|null} params.selector - CSS selector, XPath, text, or ref ID (e.g., "ref=e3") for the element
+ * @param {string} params.strategy - Selector strategy: 'css', 'xpath', or 'text'
  * @param {number|null} params.x - X coordinate
  * @param {number|null} params.y - Y coordinate
  * @param {number} params.duration - Duration for long-press
@@ -12,15 +13,22 @@
  * @param {number} params.scrollY - Vertical scroll amount
  */
 (function(params) {
-   const { action, selector, x, y, duration, scrollX, scrollY } = params;
+   const { action, selector, strategy, x, y, duration, scrollX, scrollY } = params;
 
    function resolveElement(selectorOrRef) {
       if (!selectorOrRef) return null;
-      var el = window.__MCP__.resolveRef(selectorOrRef);
+      var el = window.__MCP__.resolveRef(selectorOrRef, strategy);
       if (!el) throw new Error('Element not found: ' + selectorOrRef);
       return el;
    }
 
+   function matchHint() {
+      if (!selector) return '';
+      var count = window.__MCP__.countAll(selector, strategy);
+      if (count > 1) return ' (+' + (count - 1) + ' more match' + (count - 1 === 1 ? '' : 'es') + ')';
+      return '';
+   }
+
    let element = null;
    let targetX, targetY;
 
@@ -60,7 +68,7 @@
          element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
          element.dispatchEvent(new MouseEvent('click', eventOptions));
       }
-      return `Clicked at (${targetX}, ${targetY})`;
+      return `Clicked at (${targetX}, ${targetY})` + matchHint();
    }
 
    if (action === 'double-click') {
@@ -73,7 +81,7 @@
          element.dispatchEvent(new MouseEvent('click', eventOptions));
          element.dispatchEvent(new MouseEvent('dblclick', eventOptions));
       }
-      return `Double-clicked at (${targetX}, ${targetY})`;
+      return `Double-clicked at (${targetX}, ${targetY})` + matchHint();
    }
 
    if (action === 'long-press') {
@@ -83,7 +91,7 @@
             element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
          }, duration);
       }
-      return `Long-pressed at (${targetX}, ${targetY}) for ${duration}ms`;
+      return `Long-pressed at (${targetX}, ${targetY}) for ${duration}ms` + matchHint();
    }
 
    if (action === 'scroll') {
@@ -95,7 +103,7 @@
             scrollTarget.scrollLeft += scrollX;
             scrollTarget.scrollTop += scrollY;
          }
-         return `Scrolled by (${scrollX}, ${scrollY}) pixels`;
+         return `Scrolled by (${scrollX}, ${scrollY}) pixels` + matchHint();
       }
       return 'No scroll performed (scrollX and scrollY are both 0)';
    }