MCP Server Tauri

Instructions

Implementation Reference

• packages/mcp-server/src/tools-registry.ts:321-356 (registration)

  Tool registration defining name, description, schema, annotations, and wrapper handler that parses input and delegates to screenshot() function

  {
     name: 'tauri_webview_screenshot',
     description:
        '[Tauri Apps Only] Screenshot a running Tauri app\'s webview. ' +
        'Requires active tauri_driver_session. Captures only visible viewport. ' +
        MULTI_APP_DESC + ' ' +
        'For browser screenshots, use Chrome DevTools MCP instead. ' +
        'For Electron apps, this will NOT work.',
     category: TOOL_CATEGORIES.UI_AUTOMATION,
     schema: ScreenshotSchema,
     annotations: {
        title: 'Screenshot Tauri Webview',
        readOnlyHint: true,
        openWorldHint: false,
     },
     handler: async (args) => {
        const parsed = ScreenshotSchema.parse(args);
  
        const result = await screenshot({
           quality: parsed.quality,
           format: parsed.format,
           windowId: parsed.windowId,
           filePath: parsed.filePath,
           appIdentifier: parsed.appIdentifier,
           maxWidth: parsed.maxWidth,
        });
  
        // If saved to file, return text confirmation
        if ('filePath' in result) {
           return `Screenshot saved to: ${result.filePath}`;
        }
  
        // Return the content array directly for proper image handling
        return result.content;
     },
  },

• packages/mcp-server/src/driver/webview-interactions.ts:48-56 (schema)

  Input schema for the tool: extends WindowTargetSchema with screenshot-specific options (format, quality, filePath, maxWidth)

  export const ScreenshotSchema = WindowTargetSchema.extend({
     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)'),
     filePath: z.string().optional().describe('File path to save the screenshot to instead of returning as base64'),
     maxWidth: z.number().int().positive().optional().describe(
        'Maximum width in pixels. Images wider than this will be scaled down proportionally. ' +
        'Can also be set via TAURI_MCP_SCREENSHOT_MAX_WIDTH environment variable.'
     ),
  });

• packages/mcp-server/src/driver/webview-interactions.ts:184-224 (handler)

  Primary handler function: optionally saves screenshot to file or returns image content; delegates core capture to captureScreenshot()

  export interface ScreenshotOptions {
     quality?: number;
     format?: 'png' | 'jpeg';
     windowId?: string;
     filePath?: string;
     appIdentifier?: string | number;
     maxWidth?: number;
  }
  
  export interface ScreenshotFileResult {
     filePath: string;
     format: 'png' | 'jpeg';
  }
  
  export async function screenshot(options: ScreenshotOptions = {}): Promise<ScreenshotResult | ScreenshotFileResult> {
     const { quality, format = 'png', windowId, filePath, appIdentifier, maxWidth } = options;
  
     // Use the native screenshot function from webview-executor
     const result = await captureScreenshot({ format, quality, windowId, appIdentifier, maxWidth });
  
     // If filePath is provided, write to file instead of returning base64
     if (filePath) {
        // Find the image content in the result
        const imageContent = result.content.find((c) => { return c.type === 'image'; });
  
        if (!imageContent || imageContent.type !== 'image') {
           throw new Error('Screenshot capture failed: no image data');
        }
  
        // Decode base64 and write to file
        const buffer = Buffer.from(imageContent.data, 'base64');
  
        const resolvedPath = resolve(filePath);
  
        await writeFile(resolvedPath, buffer);
  
        return { filePath: resolvedPath, format };
     }
  
     return result;
  }

• packages/mcp-server/src/driver/webview-executor.ts:388-530 (handler)

  Core screenshot implementation: native IPC screenshot via 'capture_native_screenshot', with fallbacks to html2canvas library and Screen Capture API; constructs ToolContent image response

  export async function captureScreenshot(options: CaptureScreenshotOptions = {}): Promise<ScreenshotResult> {
     const { format = 'png', quality = 90, windowId, appIdentifier, maxWidth } = options;
  
     // 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();
  
        // Resolve target session
        const session = resolveTargetApp(appIdentifier);
  
        const client = session.client;
  
        // 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,
              windowLabel: windowId,
              maxWidth,
           },
        }, 15000);
  
        if (!response.success || !response.data) {
           throw new Error(response.error || 'Native screenshot returned invalid data');
        }
  
        // The native command returns a base64 data URL
        const dataUrl = response.data as string;
  
        if (!dataUrl || !dataUrl.startsWith('data:image/')) {
           throw new Error('Native screenshot returned invalid data');
        }
  
        // Build response with window context
        return buildScreenshotResult(dataUrl, 'native API', response.windowContext);
     } catch(nativeError: unknown) {
        // Log the native error for debugging, then fall back
        const nativeMsg = nativeError instanceof Error ? nativeError.message : String(nativeError);
  
        driverLogger.error(`Native screenshot failed: ${nativeMsg}, falling back to html2canvas`);
     }
  
     // Fallback 1: Use html2canvas library for high-quality DOM rendering
     // Try to use the script manager to register html2canvas for persistence
     const html2canvasScript = await prepareHtml2canvasScript(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, undefined, 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 buildScreenshotResult(result, 'html2canvas');
        }
  
        throw new Error(`html2canvas returned invalid result: ${result?.substring(0, 100) || 'null'}`);
     } catch(html2canvasError: unknown) {
        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 buildScreenshotResult(result, 'Screen Capture API');
           }
  
           throw new Error(`Screen Capture API returned invalid result: ${result?.substring(0, 50) || 'null'}`);
        } catch(screenCaptureError: unknown) {
           // 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}`
           );
        }
     }
  }