@hypothesi/tauri-mcp-server 0.1.1

package/dist/driver/webview-executor.js

@@ -0,0 +1,334 @@
+import { z } from 'zod';
+import { getPluginClient, connectPlugin } from './plugin-client.js';
+import { buildScreenshotScript } from './scripts/html2canvas-loader.js';
+/**
+ * WebView Executor - Native IPC-based JavaScript execution
+ *
+ * This module provides native Tauri IPC-based execution,
+ * enabling cross-platform support (Linux, Windows, macOS) without external dependencies.
+ *
+ * Communication flow:
+ * MCP Server (Node.js) → plugin-client (WebSocket) → mcp-bridge plugin → Tauri Webview
+ */
+// ============================================================================
+// Auto-Initialization System
+// ============================================================================
+let isInitialized = false;
+/**
+ * Ensures the MCP server is fully initialized and ready to use.
+ * This is called automatically by all tool functions.
+ *
+ * Initialization includes:
+ * - Connecting to the plugin WebSocket
+ * - Console capture is already initialized by bridge.js in the Tauri app
+ *
+ * This function is idempotent - calling it multiple times is safe.
+ */
+export async function ensureReady() {
+    if (isInitialized) {
+        return;
+    }
+    // Connect to the plugin
+    await connectPlugin();
+    isInitialized = true;
+}
+/**
+ * Reset initialization state (useful for testing or reconnecting).
+ */
+export function resetInitialization() {
+    isInitialized = false;
+}
+// ============================================================================
+// Core Execution Functions
+// ============================================================================
+/**
+ * Execute JavaScript in the Tauri webview using native IPC via WebSocket.
+ *
+ * @param script - JavaScript code to execute in the webview context
+ * @returns Result of the script execution as a string
+ */
+export async function executeInWebview(script) {
+    try {
+        // Ensure we're fully initialized
+        await ensureReady();
+        const client = getPluginClient();
+        // Send script directly - Rust handles wrapping and IPC callbacks.
+        // Use 7s timeout (longer than Rust's 5s) so errors return before Node times out.
+        const response = await client.sendCommand({
+            command: 'execute_js',
+            args: { script },
+        }, 7000);
+        // console.log('executeInWebview response:', JSON.stringify(response));
+        if (!response.success) {
+            throw new Error(response.error || 'Unknown execution error');
+        }
+        // Parse and return the result
+        const result = response.data;
+        // console.log('executeInWebview result data:', result, 'type:', typeof result);
+        if (result === null || result === undefined) {
+            return 'null';
+        }
+        if (typeof result === 'string') {
+            return result;
+        }
+        return JSON.stringify(result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`WebView execution failed: ${message}`);
+    }
+}
+/**
+ * Execute async JavaScript in the webview with timeout support.
+ *
+ * @param script - JavaScript code to execute (can use await)
+ * @param timeout - Timeout in milliseconds (default: 5000)
+ * @returns Result of the script execution
+ */
+export async function executeAsyncInWebview(script, timeout = 5000) {
+    const wrappedScript = `
+      return (async () => {
+         const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error('Script execution timeout')), ${timeout});
+         });
+
+         const scriptPromise = (async () => {
+            ${script}
+         })();
+
+         return await Promise.race([scriptPromise, timeoutPromise]);
+      })();
+   `;
+    return executeInWebview(wrappedScript);
+}
+// ============================================================================
+// Console Log Capture System
+// ============================================================================
+/**
+ * Initialize console log capture in the webview.
+ * This intercepts console methods and stores logs in memory.
+ *
+ * NOTE: Console capture is now automatically initialized by bridge.js when the
+ * Tauri app starts. This function is kept for backwards compatibility and will
+ * simply return early if capture is already initialized.
+ */
+export async function initializeConsoleCapture() {
+    const script = `
+      if (!window.__MCP_CONSOLE_LOGS__) {
+         window.__MCP_CONSOLE_LOGS__ = [];
+         const originalConsole = { ...console };
+
+         ['log', 'debug', 'info', 'warn', 'error'].forEach(level => {
+            console[level] = function(...args) {
+               window.__MCP_CONSOLE_LOGS__.push({
+                  level: level,
+                  message: args.map(a => {
+                     try {
+                        return typeof a === 'object' ? JSON.stringify(a) : String(a);
+                     } catch(e) {
+                        return String(a);
+                     }
+                  }).join(' '),
+                  timestamp: Date.now()
+               });
+
+               // Keep original console behavior
+               originalConsole[level].apply(console, args);
+            };
+         });
+
+         return 'Console capture initialized';
+      }
+      return 'Console capture already initialized';
+   `;
+    return executeInWebview(script);
+}
+/**
+ * Retrieve captured console logs with optional filtering.
+ *
+ * @param filter - Optional regex pattern to filter log messages
+ * @param since - Optional ISO timestamp to filter logs after this time
+ * @returns Formatted console logs as string
+ */
+export async function getConsoleLogs(filter, since) {
+    const filterStr = filter ? filter.replace(/'/g, '\\\'') : '';
+    const sinceStr = since || '';
+    const script = `
+      const logs = window.__MCP_CONSOLE_LOGS__ || [];
+      let filtered = logs;
+
+      if ('${sinceStr}') {
+         const sinceTime = new Date('${sinceStr}').getTime();
+         filtered = filtered.filter(l => l.timestamp > sinceTime);
+      }
+
+      if ('${filterStr}') {
+         try {
+            const regex = new RegExp('${filterStr}', 'i');
+            filtered = filtered.filter(l => regex.test(l.message));
+         } catch(e) {
+            throw new Error('Invalid filter regex: ' + e.message);
+         }
+      }
+
+      return filtered.map(l =>
+         '[ ' + new Date(l.timestamp).toISOString() + ' ] [ ' + l.level.toUpperCase() + ' ] ' + l.message
+      ).join('\\n');
+   `;
+    return executeInWebview(script);
+}
+/**
+ * Clear all captured console logs.
+ */
+export async function clearConsoleLogs() {
+    const script = `
+      window.__MCP_CONSOLE_LOGS__ = [];
+      return 'Console logs cleared';
+   `;
+    return executeInWebview(script);
+}
+// ============================================================================
+// Screenshot Functionality
+// ============================================================================
+/**
+ * Capture a screenshot of the entire webview.
+ *
+ * @param format - Image format: 'png' or 'jpeg'
+ * @param quality - JPEG quality (0-100), only used for jpeg format
+ * @returns Base64-encoded image data URL
+ */
+export async function captureScreenshot(format = 'png', quality = 90) {
+    // Primary implementation: Use native platform-specific APIs
+    // - macOS: WKWebView takeSnapshot
+    // - Windows: WebView2 CapturePreview
+    // - Linux: Chromium/WebKit screenshot APIs
+    try {
+        // Ensure we're fully initialized
+        await ensureReady();
+        const client = getPluginClient();
+        // Use longer timeout (15s) for native screenshot - the Rust code waits up to 10s
+        const response = await client.sendCommand({
+            command: 'capture_native_screenshot',
+            args: {
+                format,
+                quality,
+            },
+        }, 15000);
+        if (response.success && response.data) {
+            // The native command returns a base64 data URL
+            const dataUrl = response.data;
+            // Validate that we got a real data URL
+            if (dataUrl && dataUrl.startsWith('data:image/')) {
+                return `Webview screenshot captured (native):\n\n![Screenshot](${dataUrl})`;
+            }
+        }
+        // If we get here, native returned but with invalid data - throw to trigger fallback
+        throw new Error(response.error || 'Native screenshot returned invalid data');
+    }
+    catch (nativeError) {
+        // Log the native error for debugging, then fall back
+        const nativeMsg = nativeError instanceof Error ? nativeError.message : String(nativeError);
+        console.error(`Native screenshot failed: ${nativeMsg}, falling back to html2canvas`);
+    }
+    // Fallback 1: Use html2canvas library for high-quality DOM rendering
+    // The library is bundled from node_modules, not loaded from CDN
+    const html2canvasScript = buildScreenshotScript(format, quality);
+    // Fallback: Try Screen Capture API if available
+    // Note: This script is wrapped by executeAsyncInWebview, so we don't need an IIFE
+    const screenCaptureScript = `
+      // Check if Screen Capture API is available
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getDisplayMedia) {
+         throw new Error('Screen Capture API not available');
+      }
+
+      // Request screen capture permission and get the stream
+      const stream = await navigator.mediaDevices.getDisplayMedia({
+         video: {
+            displaySurface: 'window',
+            cursor: 'never'
+         },
+         audio: false
+      });
+
+      // Get the video track
+      const videoTrack = stream.getVideoTracks()[0];
+      if (!videoTrack) {
+         throw new Error('No video track available');
+      }
+
+      // Create a video element to display the stream
+      const video = document.createElement('video');
+      video.srcObject = stream;
+      video.autoplay = true;
+
+      // Wait for the video to load metadata
+      await new Promise((resolve, reject) => {
+         video.onloadedmetadata = resolve;
+         video.onerror = reject;
+         setTimeout(() => reject(new Error('Video load timeout')), 5000);
+      });
+
+      // Play the video
+      await video.play();
+
+      // Create canvas to capture the frame
+      const canvas = document.createElement('canvas');
+      const ctx = canvas.getContext('2d');
+
+      // Set canvas dimensions to match video
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+
+      // Draw the video frame to canvas
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+
+      // Stop all tracks to release the capture
+      stream.getTracks().forEach(track => track.stop());
+
+      // Convert to data URL with specified format and quality
+      const mimeType = '${format}' === 'jpeg' ? 'image/jpeg' : 'image/png';
+      return canvas.toDataURL(mimeType, ${quality / 100});
+   `;
+    try {
+        // Try html2canvas second (after native APIs)
+        const result = await executeAsyncInWebview(html2canvasScript, 10000); // Longer timeout for library loading
+        // Validate that we got a real data URL, not 'null' or empty
+        if (result && result !== 'null' && result.startsWith('data:image/')) {
+            return `Webview screenshot captured:\n\n![Screenshot](${result})`;
+        }
+        throw new Error(`html2canvas returned invalid result: ${result?.substring(0, 100) || 'null'}`);
+    }
+    catch (html2canvasError) {
+        try {
+            // Fallback to Screen Capture API
+            const result = await executeAsyncInWebview(screenCaptureScript);
+            // Validate that we got a real data URL
+            if (result && result.startsWith('data:image/')) {
+                return `Webview screenshot captured (via Screen Capture API):\n\n![Screenshot](${result})`;
+            }
+            throw new Error(`Screen Capture API returned invalid result: ${result?.substring(0, 50) || 'null'}`);
+        }
+        catch (screenCaptureError) {
+            // All methods failed - throw a proper error
+            const html2canvasMsg = html2canvasError instanceof Error ? html2canvasError.message : 'html2canvas failed';
+            const screenCaptureMsg = screenCaptureError instanceof Error ? screenCaptureError.message : 'Screen Capture API failed';
+            throw new Error('Screenshot capture failed. Native API not available, ' +
+                `html2canvas error: ${html2canvasMsg}, ` +
+                `Screen Capture API error: ${screenCaptureMsg}`);
+        }
+    }
+}
+// ============================================================================
+// Schemas for Validation
+// ============================================================================
+export const ExecuteScriptSchema = z.object({
+    script: z.string().describe('JavaScript code to execute in the webview'),
+});
+export const GetConsoleLogsSchema = z.object({
+    filter: z.string().optional().describe('Regex or keyword to filter logs'),
+    since: z.string().optional().describe('ISO timestamp to filter logs since'),
+});
+export const CaptureScreenshotSchema = z.object({
+    format: z.enum(['png', 'jpeg']).optional().default('png').describe('Image format'),
+    quality: z.number().min(0).max(100).optional().describe('JPEG quality (0-100)'),
+});

package/dist/driver/webview-interactions.js

@@ -0,0 +1,213 @@
+import { z } from 'zod';
+import { executeInWebview, captureScreenshot, getConsoleLogs as getConsoleLogsFromCapture } from './webview-executor.js';
+import { SCRIPTS, buildScript, buildTypeScript, buildKeyEventScript } from './scripts/index.js';
+// ============================================================================
+// Schemas
+// ============================================================================
+export const InteractSchema = z.object({
+    action: z.enum(['click', 'double-click', 'long-press', 'scroll', 'swipe'])
+        .describe('Type of interaction to perform'),
+    selector: z.string().optional().describe('CSS selector for the element to interact with'),
+    x: z.number().optional().describe('X coordinate for direct coordinate interaction'),
+    y: z.number().optional().describe('Y coordinate for direct coordinate interaction'),
+    duration: z.number().optional()
+        .describe('Duration in ms for long-press or swipe (default: 500ms for long-press, 300ms for swipe)'),
+    scrollX: z.number().optional().describe('Horizontal scroll amount in pixels (positive = right)'),
+    scrollY: z.number().optional().describe('Vertical scroll amount in pixels (positive = down)'),
+    // Swipe-specific parameters
+    fromX: z.number().optional().describe('Starting X coordinate for swipe'),
+    fromY: z.number().optional().describe('Starting Y coordinate for swipe'),
+    toX: z.number().optional().describe('Ending X coordinate for swipe'),
+    toY: z.number().optional().describe('Ending Y coordinate for swipe'),
+});
+export const ScreenshotSchema = z.object({
+    format: z.enum(['png', 'jpeg']).optional().default('png').describe('Image format'),
+    quality: z.number().min(0).max(100).optional().describe('JPEG quality (0-100, only for jpeg format)'),
+});
+export const KeyboardSchema = z.object({
+    action: z.enum(['type', 'press', 'down', 'up'])
+        .describe('Keyboard action type: "type" for typing text into an element, "press/down/up" for key events'),
+    selector: z.string().optional().describe('CSS selector for element to type into (required for "type" action)'),
+    text: z.string().optional().describe('Text to type (required for "type" action)'),
+    key: z.string().optional().describe('Key to press (required for "press/down/up" actions, e.g., "Enter", "a", "Escape")'),
+    modifiers: z.array(z.enum(['Control', 'Alt', 'Shift', 'Meta'])).optional().describe('Modifier keys to hold'),
+});
+export const WaitForSchema = z.object({
+    type: z.enum(['selector', 'text', 'ipc-event']).describe('What to wait for'),
+    value: z.string().describe('Selector, text content, or IPC event name to wait for'),
+    timeout: z.number().optional().default(5000).describe('Timeout in milliseconds (default: 5000ms)'),
+});
+export const GetStylesSchema = z.object({
+    selector: z.string().describe('CSS selector for element(s) to get styles from'),
+    properties: z.array(z.string()).optional().describe('Specific CSS properties to retrieve. If omitted, returns all computed styles'),
+    multiple: z.boolean().optional().default(false)
+        .describe('Whether to get styles for all matching elements (true) or just the first (false)'),
+});
+export const ExecuteJavaScriptSchema = z.object({
+    script: z.string().describe('JavaScript code to execute in the webview context'),
+    args: z.array(z.unknown()).optional().describe('Arguments to pass to the script'),
+});
+export const FocusElementSchema = z.object({
+    selector: z.string().describe('CSS selector for element to focus'),
+});
+export const FindElementSchema = z.object({
+    selector: z.string(),
+    strategy: z.enum(['css', 'xpath', 'text']).default('css'),
+});
+export const GetConsoleLogsSchema = z.object({
+    filter: z.string().optional().describe('Regex or keyword to filter logs'),
+    since: z.string().optional().describe('ISO timestamp to filter logs since'),
+});
+// ============================================================================
+// Implementation Functions
+// ============================================================================
+export async function interact(options) {
+    const { action, selector, x, y, duration, scrollX, scrollY, fromX, fromY, toX, toY } = options;
+    // Handle swipe action separately since it has different logic
+    if (action === 'swipe') {
+        return performSwipe(fromX, fromY, toX, toY, duration);
+    }
+    const script = buildScript(SCRIPTS.interact, {
+        action,
+        selector: selector ?? null,
+        x: x ?? null,
+        y: y ?? null,
+        duration: duration ?? 500,
+        scrollX: scrollX ?? 0,
+        scrollY: scrollY ?? 0,
+    });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Interaction failed: ${message}`);
+    }
+}
+async function performSwipe(fromX, fromY, toX, toY, duration = 300) {
+    if (fromX === undefined || fromY === undefined || toX === undefined || toY === undefined) {
+        throw new Error('Swipe action requires fromX, fromY, toX, and toY coordinates');
+    }
+    const script = buildScript(SCRIPTS.swipe, { fromX, fromY, toX, toY, duration });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Swipe failed: ${message}`);
+    }
+}
+export async function screenshot(quality, format = 'png') {
+    // Use the native screenshot function from webview-executor
+    return captureScreenshot(format, quality);
+}
+export async function keyboard(action, selectorOrKey, textOrModifiers, modifiers) {
+    // Handle the different parameter combinations based on action
+    if (action === 'type') {
+        const selector = selectorOrKey;
+        const text = textOrModifiers;
+        if (!selector || !text) {
+            throw new Error('Type action requires both selector and text parameters');
+        }
+        const script = buildTypeScript(selector, text);
+        try {
+            return await executeInWebview(script);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Type action failed: ${message}`);
+        }
+    }
+    // For press/down/up actions: key is required, modifiers optional
+    const key = selectorOrKey;
+    const mods = Array.isArray(textOrModifiers) ? textOrModifiers : modifiers;
+    if (!key) {
+        throw new Error(`${action} action requires a key parameter`);
+    }
+    const script = buildKeyEventScript(action, key, mods || []);
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Keyboard action failed: ${message}`);
+    }
+}
+export async function waitFor(type, value, timeout = 5000) {
+    const script = buildScript(SCRIPTS.waitFor, { type, value, timeout });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Wait failed: ${message}`);
+    }
+}
+export async function getStyles(selector, properties, multiple = false) {
+    const script = buildScript(SCRIPTS.getStyles, {
+        selector,
+        properties: properties || [],
+        multiple,
+    });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Get styles failed: ${message}`);
+    }
+}
+export async function executeJavaScript(script, args) {
+    // If args are provided, we need to inject them into the script context
+    const wrappedScript = args && args.length > 0
+        ? `
+         (function() {
+            const args = ${JSON.stringify(args)};
+            return (${script}).apply(null, args);
+         })();
+      `
+        : script;
+    try {
+        const result = await executeInWebview(wrappedScript);
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`JavaScript execution failed: ${message}`);
+    }
+}
+export async function focusElement(selector) {
+    const script = buildScript(SCRIPTS.focus, { selector });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Focus failed: ${message}`);
+    }
+}
+/**
+ * Find an element using various selector strategies.
+ */
+export async function findElement(selector, strategy) {
+    const script = buildScript(SCRIPTS.findElement, { selector, strategy });
+    try {
+        return await executeInWebview(script);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Find element failed: ${message}`);
+    }
+}
+/**
+ * Get console logs from the webview.
+ */
+export async function getConsoleLogs(filter, since) {
+    try {
+        return await getConsoleLogsFromCapture(filter, since);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to get console logs: ${message}`);
+    }
+}

package/dist/index.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+// Import the single source of truth for all tools
+import { TOOLS, TOOL_MAP } from './tools-registry.js';
+/* eslint-disable no-process-exit */
+// Read version from package.json
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(currentDir, '..', 'package.json'), 'utf-8'));
+const VERSION = packageJson.version;
+// Initialize server
+const server = new Server({
+    name: 'mcp-server-tauri',
+    version: VERSION,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle connection errors gracefully - don't crash on broken pipe
+server.onerror = (error) => {
+    // Ignore broken pipe errors - they happen when the client disconnects
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes('broken pipe') || message.includes('EPIPE')) {
+        // Client disconnected, exit gracefully
+        process.exit(0);
+    }
+    // For other errors, log to stderr (will be captured by MCP client)
+    console.error('[MCP Server Error]', message);
+};
+// Handle connection close - exit gracefully
+server.onclose = () => {
+    process.exit(0);
+};
+// Tool list handler - generated from registry
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: TOOLS.map((tool) => {
+            return {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: zodToJsonSchema(tool.schema),
+            };
+        }),
+    };
+});
+// Tool call handler - generated from registry
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const tool = TOOL_MAP.get(request.params.name);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+        const output = await tool.handler(request.params.arguments);
+        return { content: [{ type: 'text', text: output }] };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: 'text', text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Don't log to stderr - it interferes with MCP protocol
+}
+main().catch(() => {
+    // Don't log errors to stderr - just exit silently
+    // The error will be in the MCP response if needed
+    process.exit(1);
+});