@hypothesi/tauri-mcp-server 0.12.0 → 0.13.0

package/dist/driver/webview-executor.d.ts

@@ -28,18 +28,20 @@ export interface ExecuteInWebviewResult {
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | number, timeoutMs?: number): Promise<string>;
 /**
  * Execute JavaScript in the Tauri webview and return window context.
  *
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number): Promise<ExecuteInWebviewResult>;
+export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number, timeoutMs?: number, isRetry?: boolean): Promise<ExecuteInWebviewResult>;
 /**
  * Execute async JavaScript in the webview with timeout support.
  *
@@ -61,13 +63,19 @@ export declare function initializeConsoleCapture(): Promise<string>;
 /**
  * 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
- * @param windowId - Optional window label to target (defaults to "main")
- * @param appIdentifier - Optional app identifier to target specific app
+ * @param options - Filtering and formatting options
  * @returns Formatted console logs as string
  */
-export declare function getConsoleLogs(filter?: string, since?: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+export declare function getConsoleLogs(options?: {
+    filter?: string;
+    since?: string;
+    lines?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+    level?: string;
+    maxChars?: number;
+    maxCharsPerEntry?: number;
+}): Promise<string>;
 /**
  * Clear all captured console logs.
  */
@@ -85,9 +93,10 @@ export interface CaptureScreenshotOptions {
     windowId?: string;
     appIdentifier?: string | number;
     maxWidth?: number;
+    allowScreenCapture?: boolean;
 }
 /**
- * Capture a screenshot of the entire webview.
+ * Capture a screenshot of the visible webview viewport.
  *
  * @param options - Screenshot options (format, quality, windowId, appIdentifier, etc.)
  * @returns Screenshot result with image content
@@ -113,10 +122,13 @@ export declare const GetConsoleLogsSchema: z.ZodObject<{
 export declare const CaptureScreenshotSchema: z.ZodObject<{
     format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
     quality: z.ZodOptional<z.ZodNumber>;
+    allowScreenCapture: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     format: "png" | "jpeg";
+    allowScreenCapture: boolean;
     quality?: number | undefined;
 }, {
     format?: "png" | "jpeg" | undefined;
     quality?: number | undefined;
+    allowScreenCapture?: boolean | undefined;
 }>;

package/dist/driver/webview-executor.js

@@ -18,6 +18,14 @@ import { getResolveRefSource, RESOLVE_REF_SCRIPT_ID } from './scripts/index.js';
 // ============================================================================
 const initializedTargets = new Set();
 const driverLogger = createMcpLogger('DRIVER');
+const MCP_HELPER_MISSING = /__MCP__|resolveRef|resolveAll|countAll/;
+function isHelperMissingError(message) {
+    return MCP_HELPER_MISSING.test(message) &&
+        /undefined is not an object|is not a function|Cannot read propert/.test(message);
+}
+function targetKeyFor(session, windowId) {
+    return `${session.host}:${session.port}:${windowId ?? 'main'}`;
+}
 /**
  * Ensures the MCP server is fully initialized and ready to use.
  * This is called automatically by all tool functions.
@@ -43,7 +51,7 @@ export async function ensureReady(windowId, appIdentifier) {
     if (!session.client.isConnected()) {
         await session.client.connect();
     }
-    const targetKey = `${session.host}:${session.port}:${windowId ?? 'main'}`;
+    const targetKey = targetKeyFor(session, windowId);
     if (initializedTargets.has(targetKey)) {
         return;
     }
@@ -84,10 +92,11 @@ async function waitForResolveRefHelper(session, windowId) {
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export async function executeInWebview(script, windowId, appIdentifier) {
-    const { result } = await executeInWebviewWithContext(script, windowId, appIdentifier);
+export async function executeInWebview(script, windowId, appIdentifier, timeoutMs) {
+    const { result } = await executeInWebviewWithContext(script, windowId, appIdentifier, timeoutMs);
     return result;
 }
 /**
@@ -96,21 +105,38 @@ export async function executeInWebview(script, windowId, appIdentifier) {
  * @param script - JavaScript code to execute in the webview context
  * @param windowId - Optional window label to target (defaults to "main")
  * @param appIdentifier - Optional app identifier to target specific app
+ * @param timeoutMs - Optional timeout in milliseconds
  * @returns Result of the script execution with window context
  */
-export async function executeInWebviewWithContext(script, windowId, appIdentifier) {
+export async function executeInWebviewWithContext(script, windowId, appIdentifier, timeoutMs, isRetry = false) {
     try {
-        // Ensure we're fully initialized
-        await ensureReady(windowId, appIdentifier);
-        // Resolve target session
+        return await runInWebview(script, windowId, appIdentifier, timeoutMs);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (isRetry || !isHelperMissingError(message)) {
+            throw new Error(`WebView execution failed: ${message}`);
+        }
+        driverLogger.warn(`__MCP__ helper missing, re-injecting and retrying once: ${message}`);
         const session = resolveTargetApp(appIdentifier);
-        const client = session.client;
-        // Send script directly - Rust handles wrapping and IPC callbacks.
-        // Use 7s timeout (longer than Rust's 5s) so errors return before Node times out.
+        initializedTargets.delete(targetKeyFor(session, windowId));
+        await ensureReady(windowId, appIdentifier);
+        return executeInWebviewWithContext(script, windowId, appIdentifier, timeoutMs, true);
+    }
+}
+async function runInWebview(script, windowId, appIdentifier, timeoutMs) {
+    // Ensure we're fully initialized
+    await ensureReady(windowId, appIdentifier);
+    // Resolve target session
+    const session = resolveTargetApp(appIdentifier);
+    const client = session.client;
+    // Send script directly - Rust handles wrapping and IPC callbacks.
+    // Use timeoutMs if provided, otherwise default 7s timeout (longer than Rust's 5s)
+    try {
         const response = await client.sendCommand({
             command: 'execute_js',
             args: { script, windowLabel: windowId },
-        }, 7000);
+        }, timeoutMs ?? 7000);
         if (!response.success) {
             throw new Error(response.error || 'Unknown execution error');
         }
@@ -136,7 +162,34 @@ export async function executeInWebviewWithContext(script, windowId, appIdentifie
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`WebView execution failed: ${message}`);
+        // Check for transport timeout
+        if (/^Request timeout after \d+ms$/.test(message)) {
+            const probeResult = await probeBridge(session, windowId);
+            if (probeResult) {
+                throw new Error(`Bridge did not respond within ${timeoutMs ?? 7000}ms. A follow-up probe succeeded, so the bridge is alive and this ` +
+                    'specific script was too slow. Raise `timeout`, or split the work across calls.');
+            }
+            else {
+                throw new Error(`Bridge did not respond within ${timeoutMs ?? 7000}ms and a follow-up probe also timed out. The webview is wedged. ` +
+                    'Call driver_session with action "stop" then "start". A runaway loop in a previous script is the usual cause.');
+            }
+        }
+        throw error;
+    }
+}
+async function probeBridge(session, windowId) {
+    if (!session) {
+        return false;
+    }
+    try {
+        const response = await session.client.sendCommand({
+            command: 'execute_js',
+            args: { script: 'return 1', windowLabel: windowId },
+        }, 2000);
+        return response.success === true;
+    }
+    catch {
+        return false;
     }
 }
 /**
@@ -149,6 +202,7 @@ export async function executeInWebviewWithContext(script, windowId, appIdentifie
  */
 export async function executeAsyncInWebview(script, windowId, timeout, appIdentifier) {
     const resolvedTimeout = timeout ?? 5000;
+    const transportTimeout = resolvedTimeout + 2000;
     const wrappedScript = `
       return (async () => {
          const timeoutPromise = new Promise((_, reject) => {
@@ -162,7 +216,7 @@ export async function executeAsyncInWebview(script, windowId, timeout, appIdenti
          return await Promise.race([scriptPromise, timeoutPromise]);
       })();
    `;
-    return executeInWebview(wrappedScript, windowId, appIdentifier);
+    return executeInWebview(wrappedScript, windowId, appIdentifier, transportTimeout);
 }
 // ============================================================================
 // Console Log Capture System
@@ -209,14 +263,12 @@ export async function initializeConsoleCapture() {
 /**
  * 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
- * @param windowId - Optional window label to target (defaults to "main")
- * @param appIdentifier - Optional app identifier to target specific app
+ * @param options - Filtering and formatting options
  * @returns Formatted console logs as string
  */
-export async function getConsoleLogs(filter, since, windowId, appIdentifier) {
-    const filterStr = filter ? filter.replace(/'/g, '\\\'') : '';
+export async function getConsoleLogs(options = {}) {
+    const { filter, since, lines = 50, windowId, appIdentifier, level, maxChars = 20000, maxCharsPerEntry = 2000 } = options;
+    const resolvedLines = lines, resolvedMaxChars = maxChars, resolvedMaxCharsPerEntry = maxCharsPerEntry, resolvedLevel = level ?? '', filterStr = filter ? filter.replace(/'/g, '\\\'') : '', levelStr = resolvedLevel;
     const sinceStr = since || '';
     const script = `
       const logs = window.__MCP_CONSOLE_LOGS__ || [];
@@ -227,6 +279,10 @@ export async function getConsoleLogs(filter, since, windowId, appIdentifier) {
          filtered = filtered.filter(l => l.timestamp > sinceTime);
       }
 
+      if ('${levelStr}') {
+         filtered = filtered.filter(l => l.level === '${levelStr}');
+      }
+
       if ('${filterStr}') {
          try {
             const regex = new RegExp('${filterStr}', 'i');
@@ -236,9 +292,34 @@ export async function getConsoleLogs(filter, since, windowId, appIdentifier) {
          }
       }
 
-      return filtered.map(l =>
-         '[ ' + new Date(l.timestamp).toISOString() + ' ] [ ' + l.level.toUpperCase() + ' ] ' + l.message
-      ).join('\\n');
+      filtered = filtered.slice(-${resolvedLines});
+
+      var budget = ${resolvedMaxChars};
+      var dropped = 0;
+      var out = [];
+
+      for (var i = filtered.length - 1; i >= 0; i--) {
+         var entry = filtered[i],
+             excess = entry.message.length - ${resolvedMaxCharsPerEntry},
+             message = entry.message.length > ${resolvedMaxCharsPerEntry}
+                ? entry.message.slice(0, ${resolvedMaxCharsPerEntry}) + '…[' + excess + ' more chars]'
+                : entry.message,
+             prefix = '[ ' + new Date(entry.timestamp).toISOString() + ' ] [ ' + entry.level.toUpperCase() + ' ] ',
+             line = prefix + message;
+
+         if (line.length > budget) { dropped = i + 1; break; }
+         budget -= line.length + 1;
+         out.unshift(line);
+      }
+
+      if (dropped > 0) {
+         out.unshift(
+            '[ ' + dropped + ' older entries dropped to fit maxChars=' + ${resolvedMaxChars} +
+            '. Narrow with level, filter, or since. ]'
+         );
+      }
+
+      return out.join('\\n');
    `;
     return executeInWebview(script, windowId, appIdentifier);
 }
@@ -265,7 +346,7 @@ function parseDataUrl(dataUrl) {
 /**
  * Build screenshot result with image content and optional text context.
  */
-function buildScreenshotResult(dataUrl, method, windowContext) {
+function buildScreenshotResult(dataUrl, method, windowContext, metadata) {
     const parsed = parseDataUrl(dataUrl);
     if (!parsed) {
         throw new Error(`Invalid data URL format: ${dataUrl.substring(0, 50)}...`);
@@ -279,6 +360,16 @@ function buildScreenshotResult(dataUrl, method, windowContext) {
             contextText += `\n\n⚠️ ${windowContext.warning}`;
         }
     }
+    // Add screenshot metadata if available
+    if (metadata) {
+        const scale = metadata.cssWidth > 0 ? metadata.imageWidth / metadata.cssWidth : 0;
+        const inverseScale = scale > 0 ? (1 / scale).toFixed(1) : '1.0';
+        contextText += `\nImage is ${metadata.imageWidth}x${metadata.imageHeight} px. ` +
+            `Webview viewport is ${Math.round(metadata.cssWidth)}x${Math.round(metadata.cssHeight)} CSS px. ` +
+            `Scale ${scale.toFixed(3)}.`;
+        contextText += '\nwebview_interact x and y are CSS pixels: ' +
+            `multiply image coordinates by ${inverseScale}.`;
+    }
     content.push({ type: 'text', text: contextText });
     // Add the image content
     content.push({
@@ -309,49 +400,53 @@ async function prepareHtml2canvasScript(format, quality, windowId, appIdentifier
         return buildScreenshotScript(format, quality);
     }
 }
+function parseNativeScreenshotPayload(rawPayload) {
+    if (typeof rawPayload === 'string') {
+        return { dataUrl: rawPayload };
+    }
+    const payload = rawPayload, dimensions = [payload.imageWidth, payload.imageHeight, payload.cssWidth, payload.cssHeight], hasMetadata = dimensions.every((value) => { return typeof value === 'number'; });
+    if (!hasMetadata) {
+        return { dataUrl: payload.dataUrl };
+    }
+    return {
+        dataUrl: payload.dataUrl,
+        metadata: {
+            imageWidth: payload.imageWidth,
+            imageHeight: payload.imageHeight,
+            cssWidth: payload.cssWidth,
+            cssHeight: payload.cssHeight,
+        },
+    };
+}
+async function captureNativeScreenshot(options) {
+    const { format, quality, windowId, appIdentifier, maxWidth } = options;
+    await ensureReady(windowId, appIdentifier);
+    const session = resolveTargetApp(appIdentifier), args = { format, quality, windowLabel: windowId, maxWidth }, command = { command: 'capture_native_screenshot', args }, response = await session.client.sendCommand(command, 15000);
+    if (!response.success || !response.data) {
+        throw new Error(response.error || 'Native screenshot returned invalid data');
+    }
+    const { dataUrl, metadata } = parseNativeScreenshotPayload(response.data);
+    if (!dataUrl || !dataUrl.startsWith('data:image/')) {
+        throw new Error('Native screenshot returned invalid data');
+    }
+    return buildScreenshotResult(dataUrl, 'native API', response.windowContext, metadata);
+}
 /**
- * Capture a screenshot of the entire webview.
+ * Capture a screenshot of the visible webview viewport.
  *
  * @param options - Screenshot options (format, quality, windowId, appIdentifier, etc.)
  * @returns Screenshot result with image content
  */
 export async function captureScreenshot(options = {}) {
-    const { format = 'jpeg', quality = 80, windowId, appIdentifier, maxWidth } = options;
-    // Primary implementation: Use native platform-specific APIs
-    // - macOS: WKWebView takeSnapshot
-    // - Windows: WebView2 CapturePreview
-    // - Linux: Chromium/WebKit screenshot APIs
+    const { format = 'jpeg', quality = 80, windowId, appIdentifier, maxWidth, allowScreenCapture = false, } = options;
+    let nativeErrorMsg = 'Native screenshot unavailable';
     try {
-        // Ensure we're fully initialized
-        await ensureReady(windowId, appIdentifier);
-        // 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;
-        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);
+        return await captureNativeScreenshot({ format, quality, windowId, appIdentifier, maxWidth });
     }
     catch (nativeError) {
         // 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`);
+        nativeErrorMsg = nativeError instanceof Error ? nativeError.message : String(nativeError);
+        driverLogger.error(`Native screenshot failed: ${nativeErrorMsg}, 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
@@ -422,6 +517,12 @@ export async function captureScreenshot(options = {}) {
         throw new Error(`html2canvas returned invalid result: ${result?.substring(0, 100) || 'null'}`);
     }
     catch (html2canvasError) {
+        const html2canvasMsg = html2canvasError instanceof Error ? html2canvasError.message : 'html2canvas failed';
+        if (!allowScreenCapture) {
+            throw new Error(`Screenshot capture failed. Native API error: ${nativeErrorMsg}, ` +
+                `html2canvas error: ${html2canvasMsg}. ` +
+                'Screen Capture API fallback is disabled; set allowScreenCapture to true to request interactive permission.');
+        }
         try {
             // Fallback to Screen Capture API
             const result = await executeAsyncInWebview(screenCaptureScript, windowId, 5000, appIdentifier);
@@ -433,9 +534,8 @@ export async function captureScreenshot(options = {}) {
         }
         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, ' +
+            throw new Error(`Screenshot capture failed. Native API error: ${nativeErrorMsg}, ` +
                 `html2canvas error: ${html2canvasMsg}, ` +
                 `Screen Capture API error: ${screenCaptureMsg}`);
         }
@@ -454,4 +554,5 @@ export const GetConsoleLogsSchema = z.object({
 export const CaptureScreenshotSchema = z.object({
     format: z.enum(['png', 'jpeg']).optional().default('jpeg').describe('Image format'),
     quality: z.number().min(0).max(100).optional().describe('JPEG quality (0-100)'),
+    allowScreenCapture: z.boolean().optional().default(false).describe('Allow the Screen Capture API fallback, which opens an interactive OS permission prompt'),
 });