@hypothesi/tauri-mcp-server 0.1.1

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

@@ -0,0 +1,86 @@
+/**
+ * html2canvas library loader
+ *
+ * Loads the html2canvas library from node_modules and provides it as a string
+ * that can be injected into the webview.
+ */
+import { readFileSync } from 'fs';
+import { createRequire } from 'module';
+// Use createRequire to resolve the path to html2canvas in node_modules
+const require = createRequire(import.meta.url);
+let html2canvasSource = null;
+/**
+ * Get the html2canvas library source code.
+ * Loaded lazily and cached.
+ */
+export function getHtml2CanvasSource() {
+    if (html2canvasSource === null) {
+        // Resolve the path to html2canvas.min.js
+        const html2canvasPath = require.resolve('html2canvas/dist/html2canvas.min.js');
+        html2canvasSource = readFileSync(html2canvasPath, 'utf-8');
+    }
+    return html2canvasSource;
+}
+/**
+ * Build a script that injects html2canvas and captures a screenshot.
+ */
+export function buildScreenshotScript(format, quality) {
+    const html2canvas = getHtml2CanvasSource();
+    // Note: This script is wrapped by executeAsyncInWebview, so we don't need an IIFE
+    // The wrapper adds: (async () => { const scriptPromise = (async () => { ...script... })(); ... })()
+    return `
+      try {
+         // Inject html2canvas if not already present
+         // The library uses UMD and may set on globalThis, self, or window
+         if (typeof html2canvas === 'undefined') {
+            ${html2canvas}
+            // After loading, html2canvas should be on globalThis/self/window
+         }
+
+         // Get the html2canvas function (may be on window, self, or globalThis)
+         const html2canvasFn = typeof html2canvas !== 'undefined' ? html2canvas :
+                              (typeof window !== 'undefined' && window.html2canvas) ? window.html2canvas :
+                              (typeof self !== 'undefined' && self.html2canvas) ? self.html2canvas :
+                              (typeof globalThis !== 'undefined' && globalThis.html2canvas) ? globalThis.html2canvas : null;
+
+         if (!html2canvasFn) {
+            throw new Error('html2canvas failed to load - function not found on any global');
+         }
+
+         // Capture the entire document
+         const element = document.documentElement;
+         if (!element) {
+            throw new Error('document.documentElement is null');
+         }
+
+         // Configure html2canvas options
+         const options = {
+            backgroundColor: null,
+            scale: window.devicePixelRatio || 1,
+            logging: false,
+            useCORS: true,
+            allowTaint: false,
+            imageTimeout: 5000,
+         };
+
+         // Capture the webview
+         const canvas = await html2canvasFn(element, options);
+         if (!canvas) {
+            throw new Error('html2canvas returned null canvas');
+         }
+
+         // Convert to data URL
+         const mimeType = '${format}' === 'jpeg' ? 'image/jpeg' : 'image/png';
+         const dataUrl = canvas.toDataURL(mimeType, ${quality / 100});
+
+         if (!dataUrl || !dataUrl.startsWith('data:image/')) {
+            throw new Error('canvas.toDataURL returned invalid result: ' + (dataUrl ? dataUrl.substring(0, 50) : 'null'));
+         }
+
+         return dataUrl;
+      } catch (screenshotError) {
+         // Re-throw with more context
+         throw new Error('Screenshot capture failed: ' + (screenshotError.message || String(screenshotError)));
+      }
+   `;
+}

package/dist/driver/scripts/index.js

@@ -0,0 +1,94 @@
+/**
+ * Script loader for webview injection scripts
+ *
+ * These scripts are loaded at build time and injected into the webview at runtime.
+ * Each script is an IIFE that accepts a params object.
+ */
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const currentDir = dirname(fileURLToPath(import.meta.url));
+function loadScript(name) {
+    return readFileSync(join(currentDir, `${name}.js`), 'utf-8');
+}
+// Load scripts once at module initialization
+export const SCRIPTS = {
+    interact: loadScript('interact'),
+    swipe: loadScript('swipe'),
+    keyboard: loadScript('keyboard'),
+    waitFor: loadScript('wait-for'),
+    getStyles: loadScript('get-styles'),
+    focus: loadScript('focus'),
+    findElement: loadScript('find-element'),
+};
+/**
+ * Build a script invocation with parameters
+ * The script should be an IIFE that accepts a params object
+ */
+export function buildScript(script, params) {
+    return `(${script})(${JSON.stringify(params)})`;
+}
+/**
+ * Build a script for typing text (uses the keyboard script's typeText function)
+ */
+export function buildTypeScript(selector, text) {
+    const escapedText = text.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    return `
+      (function() {
+         const selector = '${selector}';
+         const text = '${escapedText}';
+
+         const element = document.querySelector(selector);
+         if (!element) {
+            throw new Error('Element not found: ' + selector);
+         }
+
+         element.focus();
+         element.value = text;
+         element.dispatchEvent(new Event('input', { bubbles: true }));
+         element.dispatchEvent(new Event('change', { bubbles: true }));
+
+         return 'Typed "' + text + '" into ' + selector;
+      })()
+   `;
+}
+/**
+ * Build a script for key events (press, down, up)
+ */
+export function buildKeyEventScript(action, key, modifiers = []) {
+    return `
+      (function() {
+         const action = '${action}';
+         const key = '${key}';
+         const modifiers = ${JSON.stringify(modifiers)};
+
+         const eventOptions = {
+            key: key,
+            code: key,
+            bubbles: true,
+            cancelable: true,
+            ctrlKey: modifiers.includes('Control'),
+            altKey: modifiers.includes('Alt'),
+            shiftKey: modifiers.includes('Shift'),
+            metaKey: modifiers.includes('Meta'),
+         };
+
+         const activeElement = document.activeElement || document.body;
+
+         if (action === 'press') {
+            activeElement.dispatchEvent(new KeyboardEvent('keydown', eventOptions));
+            activeElement.dispatchEvent(new KeyboardEvent('keypress', eventOptions));
+            activeElement.dispatchEvent(new KeyboardEvent('keyup', eventOptions));
+            return 'Pressed key: ' + key + (modifiers.length ? ' with ' + modifiers.join('+') : '');
+         } else if (action === 'down') {
+            activeElement.dispatchEvent(new KeyboardEvent('keydown', eventOptions));
+            return 'Key down: ' + key + (modifiers.length ? ' with ' + modifiers.join('+') : '');
+         } else if (action === 'up') {
+            activeElement.dispatchEvent(new KeyboardEvent('keyup', eventOptions));
+            return 'Key up: ' + key + (modifiers.length ? ' with ' + modifiers.join('+') : '');
+         }
+
+         throw new Error('Unknown action: ' + action);
+      })()
+   `;
+}

package/dist/driver/scripts/interact.js

@@ -0,0 +1,103 @@
+/**
+ * Webview interaction script - handles click, double-click, long-press, and scroll actions
+ * This script is injected into the webview and executed with parameters.
+ *
+ * @param {Object} params
+ * @param {string} params.action - The action to perform
+ * @param {string|null} params.selector - CSS selector for the element
+ * @param {number|null} params.x - X coordinate
+ * @param {number|null} params.y - Y coordinate
+ * @param {number} params.duration - Duration for long-press
+ * @param {number} params.scrollX - Horizontal scroll amount
+ * @param {number} params.scrollY - Vertical scroll amount
+ */
+(function(params) {
+   const { action, selector, x, y, duration, scrollX, scrollY } = params;
+
+   let element = null;
+   let targetX, targetY;
+
+   // For scroll action, we don't necessarily need a selector or coordinates
+   if (action === 'scroll') {
+      if (selector) {
+         element = document.querySelector(selector);
+         if (!element) {
+            throw new Error(`Element not found: ${selector}`);
+         }
+      }
+   } else {
+      // For other actions, we need either selector or coordinates
+      if (selector) {
+         element = document.querySelector(selector);
+         if (!element) {
+            throw new Error(`Element not found: ${selector}`);
+         }
+         const rect = element.getBoundingClientRect();
+         targetX = rect.left + rect.width / 2;
+         targetY = rect.top + rect.height / 2;
+      } else if (x !== null && y !== null) {
+         targetX = x;
+         targetY = y;
+         element = document.elementFromPoint(x, y);
+      } else {
+         throw new Error('Either selector or coordinates (x, y) must be provided');
+      }
+   }
+
+   // Perform the interaction
+   const eventOptions = {
+      bubbles: true,
+      cancelable: true,
+      view: window,
+      clientX: targetX,
+      clientY: targetY,
+   };
+
+   if (action === 'click') {
+      if (element) {
+         element.dispatchEvent(new MouseEvent('mousedown', eventOptions));
+         element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
+         element.dispatchEvent(new MouseEvent('click', eventOptions));
+      }
+      return `Clicked at (${targetX}, ${targetY})`;
+   }
+
+   if (action === 'double-click') {
+      if (element) {
+         element.dispatchEvent(new MouseEvent('mousedown', eventOptions));
+         element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
+         element.dispatchEvent(new MouseEvent('click', eventOptions));
+         element.dispatchEvent(new MouseEvent('mousedown', eventOptions));
+         element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
+         element.dispatchEvent(new MouseEvent('click', eventOptions));
+         element.dispatchEvent(new MouseEvent('dblclick', eventOptions));
+      }
+      return `Double-clicked at (${targetX}, ${targetY})`;
+   }
+
+   if (action === 'long-press') {
+      if (element) {
+         element.dispatchEvent(new MouseEvent('mousedown', eventOptions));
+         setTimeout(() => {
+            element.dispatchEvent(new MouseEvent('mouseup', eventOptions));
+         }, duration);
+      }
+      return `Long-pressed at (${targetX}, ${targetY}) for ${duration}ms`;
+   }
+
+   if (action === 'scroll') {
+      const scrollTarget = element || window;
+      if (scrollX !== 0 || scrollY !== 0) {
+         if (scrollTarget === window) {
+            window.scrollBy(scrollX, scrollY);
+         } else {
+            scrollTarget.scrollLeft += scrollX;
+            scrollTarget.scrollTop += scrollY;
+         }
+         return `Scrolled by (${scrollX}, ${scrollY}) pixels`;
+      }
+      return 'No scroll performed (scrollX and scrollY are both 0)';
+   }
+
+   throw new Error(`Unknown action: ${action}`);
+})

package/dist/driver/scripts/keyboard.js

@@ -0,0 +1,76 @@
+/**
+ * Keyboard interaction scripts
+ */
+
+/**
+ * Type text into an element
+ * @param {Object} params
+ * @param {string} params.selector - CSS selector for the element
+ * @param {string} params.text - Text to type
+ */
+function typeText(params) {
+   const { selector, text } = params;
+
+   const element = document.querySelector(selector);
+   if (!element) {
+      throw new Error(`Element not found: ${selector}`);
+   }
+
+   // Focus the element
+   element.focus();
+
+   // Set the value
+   element.value = text;
+
+   // Trigger input event for frameworks that listen to it
+   element.dispatchEvent(new Event('input', { bubbles: true }));
+   element.dispatchEvent(new Event('change', { bubbles: true }));
+
+   return `Typed "${text}" into ${selector}`;
+}
+
+/**
+ * Send keyboard events (press, down, up)
+ * @param {Object} params
+ * @param {string} params.action - 'press', 'down', or 'up'
+ * @param {string} params.key - Key to press
+ * @param {string[]} params.modifiers - Modifier keys
+ */
+function keyEvent(params) {
+   const { action, key, modifiers } = params;
+
+   const eventOptions = {
+      key: key,
+      code: key,
+      bubbles: true,
+      cancelable: true,
+      ctrlKey: modifiers.includes('Control'),
+      altKey: modifiers.includes('Alt'),
+      shiftKey: modifiers.includes('Shift'),
+      metaKey: modifiers.includes('Meta'),
+   };
+
+   const activeElement = document.activeElement || document.body;
+
+   if (action === 'press') {
+      activeElement.dispatchEvent(new KeyboardEvent('keydown', eventOptions));
+      activeElement.dispatchEvent(new KeyboardEvent('keypress', eventOptions));
+      activeElement.dispatchEvent(new KeyboardEvent('keyup', eventOptions));
+      return `Pressed key: ${key}${modifiers.length ? ' with ' + modifiers.join('+') : ''}`;
+   }
+
+   if (action === 'down') {
+      activeElement.dispatchEvent(new KeyboardEvent('keydown', eventOptions));
+      return `Key down: ${key}${modifiers.length ? ' with ' + modifiers.join('+') : ''}`;
+   }
+
+   if (action === 'up') {
+      activeElement.dispatchEvent(new KeyboardEvent('keyup', eventOptions));
+      return `Key up: ${key}${modifiers.length ? ' with ' + modifiers.join('+') : ''}`;
+   }
+
+   throw new Error(`Unknown action: ${action}`);
+}
+
+// Export for use
+({ typeText, keyEvent })

package/dist/driver/scripts/swipe.js

@@ -0,0 +1,88 @@
+/**
+ * Swipe gesture script - handles touch/mouse swipe actions
+ * Falls back to mouse events on desktop environments
+ *
+ * @param {Object} params
+ * @param {number} params.fromX - Starting X coordinate
+ * @param {number} params.fromY - Starting Y coordinate
+ * @param {number} params.toX - Ending X coordinate
+ * @param {number} params.toY - Ending Y coordinate
+ * @param {number} params.duration - Duration of swipe in ms
+ */
+(function(params) {
+   const { fromX, fromY, toX, toY, duration } = params;
+
+   const element = document.elementFromPoint(fromX, fromY) || document.body;
+
+   function simulateWithMouse() {
+      const mouseDown = new MouseEvent('mousedown', {
+         clientX: fromX,
+         clientY: fromY,
+         bubbles: true,
+         cancelable: true,
+      });
+
+      const mouseMove = new MouseEvent('mousemove', {
+         clientX: toX,
+         clientY: toY,
+         bubbles: true,
+         cancelable: true,
+      });
+
+      const mouseUp = new MouseEvent('mouseup', {
+         clientX: toX,
+         clientY: toY,
+         bubbles: true,
+         cancelable: true,
+      });
+
+      element.dispatchEvent(mouseDown);
+      setTimeout(() => {
+         element.dispatchEvent(mouseMove);
+         element.dispatchEvent(mouseUp);
+      }, duration);
+   }
+
+   // Check if TouchEvent is available (mobile/touch devices)
+   if (typeof TouchEvent !== 'undefined') {
+      try {
+         const touchStart = new TouchEvent('touchstart', {
+            touches: [{
+               clientX: fromX,
+               clientY: fromY,
+               target: element,
+            }],
+         });
+
+         const touchMove = new TouchEvent('touchmove', {
+            touches: [{
+               clientX: toX,
+               clientY: toY,
+               target: element,
+            }],
+         });
+
+         const touchEnd = new TouchEvent('touchend', {
+            changedTouches: [{
+               clientX: toX,
+               clientY: toY,
+               target: element,
+            }],
+         });
+
+         element.dispatchEvent(touchStart);
+         setTimeout(() => {
+            element.dispatchEvent(touchMove);
+            element.dispatchEvent(touchEnd);
+         }, duration);
+      } catch (e) {
+         // Fallback to mouse events if TouchEvent construction fails
+         simulateWithMouse();
+      }
+   } else {
+      // Use mouse events for desktop
+      simulateWithMouse();
+   }
+
+   return `Swiped from (${fromX}, ${fromY}) to (${toX}, ${toY}) in ${duration}ms`;
+})

package/dist/driver/scripts/wait-for.js

@@ -0,0 +1,44 @@
+/**
+ * Wait for conditions script - waits for selectors, text, or events
+ *
+ * @param {Object} params
+ * @param {string} params.type - What to wait for: 'selector', 'text', 'ipc-event'
+ * @param {string} params.value - Selector, text, or event name to wait for
+ * @param {number} params.timeout - Timeout in milliseconds
+ */
+(async function(params) {
+   const { type, value, timeout } = params;
+   const startTime = Date.now();
+
+   return new Promise((resolve, reject) => {
+      function check() {
+         if (Date.now() - startTime > timeout) {
+            reject(new Error(`Timeout waiting for ${type}: ${value}`));
+            return;
+         }
+
+         if (type === 'selector') {
+            const element = document.querySelector(value);
+            if (element) {
+               resolve(`Element found: ${value}`);
+               return;
+            }
+         } else if (type === 'text') {
+            const found = document.body.innerText.includes(value);
+            if (found) {
+               resolve(`Text found: ${value}`);
+               return;
+            }
+         } else if (type === 'ipc-event') {
+            // For IPC events, we'd need to set up a listener
+            // This is a simplified version
+            reject(new Error('IPC event waiting not yet implemented in this context'));
+            return;
+         }
+
+         setTimeout(check, 100);
+      }
+
+      check();
+   });
+})

package/dist/driver/session-manager.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { getDefaultHost, getDefaultPort } from '../config.js';
+import { AppDiscovery } from './app-discovery.js';
+import { resetPluginClient } from './plugin-client.js';
+import { resetInitialization } from './webview-executor.js';
+/**
+ * Session Manager - Native IPC-based session management
+ *
+ * This module provides lightweight native session management using Tauri IPC.
+ * The "session" concept is maintained for API compatibility.
+ *
+ * Connection Strategy:
+ * 1. Try localhost first (most reliable for simulators/emulators/desktop)
+ * 2. If localhost fails and a remote host is configured, try that host
+ * 3. Return error if all connection attempts fail
+ */
+// ============================================================================
+// Schemas
+// ============================================================================
+export const ManageDriverSessionSchema = z.object({
+    action: z.enum(['start', 'stop']).describe('Action to perform: start or stop the session'),
+    host: z.string().optional().describe('Host address to connect to (e.g., 192.168.1.100). Falls back to MCP_BRIDGE_HOST or TAURI_DEV_HOST env vars'),
+    port: z.number().optional().describe('Port to connect to (default: 9223)'),
+});
+// ============================================================================
+// Module State
+// ============================================================================
+// AppDiscovery instance - recreated when host changes
+let appDiscovery = null;
+function getAppDiscovery(host) {
+    if (!appDiscovery || appDiscovery.host !== host) {
+        appDiscovery = new AppDiscovery(host);
+    }
+    return appDiscovery;
+}
+// ============================================================================
+// Session Management
+// ============================================================================
+/**
+ * Try to connect to a specific host and port.
+ * Returns session info on success, throws on failure.
+ */
+async function tryConnect(host, port) {
+    const discovery = getAppDiscovery(host);
+    const session = await discovery.connectToPort(port, undefined, host);
+    return {
+        name: session.name,
+        host: session.host,
+        port: session.port,
+    };
+}
+/**
+ * Manage session lifecycle (start or stop).
+ *
+ * Connection strategy for 'start':
+ * 1. Try localhost:{port} first (most reliable for simulators/emulators/desktop)
+ * 2. If localhost fails AND a different host is configured, try {host}:{port}
+ * 3. If both fail, try auto-discovery on localhost
+ * 4. Return error if all attempts fail
+ *
+ * @param action - 'start' or 'stop'
+ * @param host - Optional host address (defaults to env var or localhost)
+ * @param port - Optional port number (defaults to 9223)
+ */
+export async function manageDriverSession(action, host, port) {
+    if (action === 'start') {
+        // Reset any existing plugin client to ensure fresh connection
+        resetPluginClient();
+        const configuredHost = host ?? getDefaultHost();
+        const configuredPort = port ?? getDefaultPort();
+        // Strategy 1: Try localhost first (most reliable)
+        if (configuredHost !== 'localhost' && configuredHost !== '127.0.0.1') {
+            try {
+                const session = await tryConnect('localhost', configuredPort);
+                return `Session started with app: ${session.name} (localhost:${session.port})`;
+            }
+            catch {
+                // Localhost failed, will try configured host next
+            }
+        }
+        // Strategy 2: Try the configured/provided host
+        try {
+            const session = await tryConnect(configuredHost, configuredPort);
+            return `Session started with app: ${session.name} (${session.host}:${session.port})`;
+        }
+        catch {
+            // Configured host failed
+        }
+        // Strategy 3: Auto-discover on localhost (scan port range)
+        const localhostDiscovery = getAppDiscovery('localhost');
+        const firstApp = await localhostDiscovery.getFirstAvailableApp();
+        if (firstApp) {
+            try {
+                // Reset client again to connect to discovered port
+                resetPluginClient();
+                const session = await tryConnect('localhost', firstApp.port);
+                return `Session started with app: ${session.name} (localhost:${session.port})`;
+            }
+            catch {
+                // Discovery found app but connection failed
+            }
+        }
+        // Strategy 4: Try default port on configured host as last resort
+        try {
+            resetPluginClient();
+            const session = await tryConnect(configuredHost, configuredPort);
+            return `Session started with app: ${session.name} (${session.host}:${session.port})`;
+        }
+        catch {
+            // All attempts failed
+            return `Session started (native IPC mode - no Tauri app found at localhost or ${configuredHost}:${configuredPort})`;
+        }
+    }
+    // Stop action - disconnect all apps and reset initialization state
+    if (appDiscovery) {
+        await appDiscovery.disconnectAll();
+    }
+    resetPluginClient();
+    resetInitialization();
+    return 'Session stopped';
+}