@hypothesi/tauri-mcp-server 0.11.2 → 0.13.0

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'),
 });

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

@@ -18,9 +18,10 @@ export declare const InteractSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;
     appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 } & {
-    action: z.ZodEnum<["click", "double-click", "long-press", "scroll", "swipe", "focus"]>;
+    action: z.ZodEnum<["click", "double-click", "long-press", "scroll", "swipe", "focus", "hover", "right-click"]>;
     selector: z.ZodOptional<z.ZodString>;
     strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    nth: z.ZodOptional<z.ZodNumber>;
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
     duration: z.ZodOptional<z.ZodNumber>;
@@ -31,11 +32,12 @@ export declare const InteractSchema: z.ZodObject<{
     toX: z.ZodOptional<z.ZodNumber>;
     toY: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll" | "hover" | "right-click";
     strategy: "css" | "text" | "xpath";
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     selector?: string | undefined;
+    nth?: number | undefined;
     x?: number | undefined;
     y?: number | undefined;
     duration?: number | undefined;
@@ -46,11 +48,12 @@ export declare const InteractSchema: z.ZodObject<{
     toX?: number | undefined;
     toY?: number | undefined;
 }, {
-    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll" | "hover" | "right-click";
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     selector?: string | undefined;
     strategy?: "css" | "text" | "xpath" | undefined;
+    nth?: number | undefined;
     x?: number | undefined;
     y?: number | undefined;
     duration?: number | undefined;
@@ -69,19 +72,22 @@ export declare const ScreenshotSchema: z.ZodObject<{
     quality: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     filePath: z.ZodOptional<z.ZodString>;
     maxWidth: z.ZodOptional<z.ZodNumber>;
+    allowScreenCapture: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     format: "png" | "jpeg";
     quality: number;
+    allowScreenCapture: boolean;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     maxWidth?: number | undefined;
     filePath?: string | undefined;
 }, {
-    format?: "png" | "jpeg" | undefined;
-    quality?: number | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    format?: "png" | "jpeg" | undefined;
+    quality?: number | undefined;
     maxWidth?: number | undefined;
+    allowScreenCapture?: boolean | undefined;
     filePath?: string | undefined;
 }>;
 export declare const KeyboardSchema: z.ZodObject<{
@@ -91,25 +97,28 @@ export declare const KeyboardSchema: z.ZodObject<{
     action: z.ZodEnum<["type", "press", "down", "up"]>;
     selector: z.ZodOptional<z.ZodString>;
     strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    nth: z.ZodOptional<z.ZodNumber>;
     text: z.ZodOptional<z.ZodString>;
     key: z.ZodOptional<z.ZodString>;
     modifiers: z.ZodOptional<z.ZodArray<z.ZodEnum<["Control", "Alt", "Shift", "Meta"]>, "many">>;
 }, "strip", z.ZodTypeAny, {
     action: "type" | "press" | "down" | "up";
     strategy: "css" | "text" | "xpath";
-    text?: string | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    text?: string | undefined;
     selector?: string | undefined;
+    nth?: number | undefined;
     key?: string | undefined;
     modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
 }, {
     action: "type" | "press" | "down" | "up";
-    text?: string | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    text?: string | undefined;
     selector?: string | undefined;
     strategy?: "css" | "text" | "xpath" | undefined;
+    nth?: number | undefined;
     key?: string | undefined;
     modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
 }>;
@@ -124,40 +133,17 @@ export declare const WaitForSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     value: string;
     type: "text" | "selector" | "ipc-event";
-    strategy: "css" | "text" | "xpath";
     timeout: number;
+    strategy: "css" | "text" | "xpath";
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
 }, {
     value: string;
     type: "text" | "selector" | "ipc-event";
-    windowId?: string | undefined;
-    appIdentifier?: string | number | undefined;
-    strategy?: "css" | "text" | "xpath" | undefined;
     timeout?: number | undefined;
-}>;
-export declare const GetStylesSchema: z.ZodObject<{
-    windowId: z.ZodOptional<z.ZodString>;
-    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-} & {
-    selector: z.ZodString;
-    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
-    properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    multiple: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    selector: string;
-    strategy: "css" | "text" | "xpath";
-    multiple: boolean;
-    windowId?: string | undefined;
-    appIdentifier?: string | number | undefined;
-    properties?: string[] | undefined;
-}, {
-    selector: string;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     strategy?: "css" | "text" | "xpath" | undefined;
-    properties?: string[] | undefined;
-    multiple?: boolean | undefined;
 }>;
 export declare const ExecuteJavaScriptSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;
@@ -165,13 +151,16 @@ export declare const ExecuteJavaScriptSchema: z.ZodObject<{
 } & {
     script: z.ZodString;
     args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+    timeout: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     script: string;
+    timeout?: number | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     args?: unknown[] | undefined;
 }, {
     script: string;
+    timeout?: number | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     args?: unknown[] | undefined;
@@ -181,14 +170,20 @@ export declare const FocusElementSchema: z.ZodObject<{
     appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 } & {
     selector: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    nth: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     selector: string;
+    strategy: "css" | "text" | "xpath";
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    nth?: number | undefined;
 }, {
     selector: string;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    nth?: number | undefined;
 }>;
 export declare const FindElementSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;
@@ -196,16 +191,31 @@ export declare const FindElementSchema: z.ZodObject<{
 } & {
     selector: z.ZodString;
     strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    nth: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    visibleOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeHtml: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     selector: string;
     strategy: "css" | "text" | "xpath";
+    limit: number;
+    visibleOnly: boolean;
+    includeHtml: boolean;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
+    nth?: number | undefined;
+    properties?: string[] | undefined;
 }, {
     selector: string;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
     strategy?: "css" | "text" | "xpath" | undefined;
+    nth?: number | undefined;
+    limit?: number | undefined;
+    properties?: string[] | undefined;
+    visibleOnly?: boolean | undefined;
+    includeHtml?: boolean | undefined;
 }>;
 export declare const GetConsoleLogsSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;
@@ -215,14 +225,14 @@ export declare const GetConsoleLogsSchema: z.ZodObject<{
     since: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     filter?: string | undefined;
+    since?: string | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
-    since?: string | undefined;
 }, {
     filter?: string | undefined;
+    since?: string | undefined;
     windowId?: string | undefined;
     appIdentifier?: string | number | undefined;
-    since?: string | undefined;
 }>;
 export declare const DomSnapshotSchema: z.ZodObject<{
     windowId: z.ZodOptional<z.ZodString>;
@@ -248,6 +258,7 @@ export declare function interact(options: {
     action: string;
     selector?: string;
     strategy?: string;
+    nth?: number;
     x?: number;
     y?: number;
     duration?: number;
@@ -267,6 +278,7 @@ export interface ScreenshotOptions {
     filePath?: string;
     appIdentifier?: string | number;
     maxWidth?: number;
+    allowScreenCapture?: boolean;
 }
 export interface ScreenshotFileResult {
     filePath: string;
@@ -277,6 +289,7 @@ export interface KeyboardOptions {
     action: string;
     selectorOrKey?: string;
     strategy?: string;
+    nth?: number;
     textOrModifiers?: string | string[];
     modifiers?: string[];
     windowId?: string;
@@ -292,18 +305,10 @@ export interface WaitForOptions {
     appIdentifier?: string | number;
 }
 export declare function waitFor(options: WaitForOptions): Promise<string>;
-export interface GetStylesOptions {
-    selector: string;
-    strategy?: string;
-    properties?: string[];
-    multiple?: boolean;
-    windowId?: string;
-    appIdentifier?: string | number;
-}
-export declare function getStyles(options: GetStylesOptions): Promise<string>;
 export interface ExecuteJavaScriptOptions {
     script: string;
     args?: unknown[];
+    timeout?: number;
     windowId?: string;
     appIdentifier?: string | number;
 }
@@ -311,6 +316,7 @@ export declare function executeJavaScript(options: ExecuteJavaScriptOptions): Pr
 export interface FocusElementOptions {
     selector: string;
     strategy?: string;
+    nth?: number;
     windowId?: string;
     appIdentifier?: string | number;
 }
@@ -318,6 +324,11 @@ export declare function focusElement(options: FocusElementOptions): Promise<stri
 export interface FindElementOptions {
     selector: string;
     strategy: string;
+    nth?: number;
+    limit?: number;
+    properties?: string[];
+    visibleOnly?: boolean;
+    includeHtml?: boolean;
     windowId?: string;
     appIdentifier?: string | number;
 }
@@ -326,6 +337,10 @@ export interface FindElementOptions {
  */
 export declare function findElement(options: FindElementOptions): Promise<string>;
 export interface GetConsoleLogsOptions {
+    lines?: number;
+    level?: 'log' | 'debug' | 'info' | 'warn' | 'error';
+    maxChars?: number;
+    maxCharsPerEntry?: number;
     filter?: string;
     since?: string;
     windowId?: string;