@hypothesi/tauri-mcp-server 0.9.0 → 0.11.0

package/dist/driver/script-manager.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Script Manager - Manages persistent script injection across page navigations.
+ *
+ * This module provides functions to register, remove, and manage scripts that
+ * should be automatically re-injected when pages load or navigate.
+ *
+ * @internal This module is for internal use only and is not exposed as MCP tools.
+ */
+/**
+ * Type of script to inject.
+ */
+export type ScriptType = 'inline' | 'url';
+/**
+ * A script entry in the registry.
+ */
+export interface ScriptEntry {
+    /** Unique identifier for this script. */
+    id: string;
+    /** Type of script (inline code or external URL). */
+    type: ScriptType;
+    /** The script content (JavaScript code) or URL. */
+    content: string;
+}
+/**
+ * Response from script registration.
+ */
+interface RegisterScriptResponse {
+    registered: boolean;
+    scriptId: string;
+}
+/**
+ * Response from script removal.
+ */
+interface RemoveScriptResponse {
+    removed: boolean;
+    scriptId: string;
+}
+/**
+ * Response from clearing scripts.
+ */
+interface ClearScriptsResponse {
+    cleared: number;
+}
+/**
+ * Response from getting scripts.
+ */
+interface GetScriptsResponse {
+    scripts: ScriptEntry[];
+}
+/**
+ * Registers a script to be injected into the webview.
+ *
+ * The script will be immediately injected if the page is loaded, and will be
+ * automatically re-injected on subsequent page loads/navigations.
+ *
+ * @param id - Unique identifier for the script
+ * @param type - Type of script ('inline' for code, 'url' for external script)
+ * @param content - The script content (JavaScript code) or URL
+ * @param windowLabel - Optional window label to target
+ * @returns Promise resolving to registration result
+ */
+export declare function registerScript(id: string, type: ScriptType, content: string, windowLabel?: string, appIdentifier?: string | number): Promise<RegisterScriptResponse>;
+/**
+ * Removes a script from the registry and DOM.
+ *
+ * @param id - The script ID to remove
+ * @param windowLabel - Optional window label to target
+ * @returns Promise resolving to removal result
+ */
+export declare function removeScript(id: string, windowLabel?: string, appIdentifier?: string | number): Promise<RemoveScriptResponse>;
+/**
+ * Clears all registered scripts from the registry and DOM.
+ *
+ * @param windowLabel - Optional window label to target
+ * @returns Promise resolving to the number of scripts cleared
+ */
+export declare function clearScripts(windowLabel?: string, appIdentifier?: string | number): Promise<ClearScriptsResponse>;
+/**
+ * Gets all registered scripts.
+ *
+ * @returns Promise resolving to the list of registered scripts
+ */
+export declare function getScripts(appIdentifier?: string | number): Promise<GetScriptsResponse>;
+/**
+ * Checks if a script with the given ID is registered.
+ *
+ * @param id - The script ID to check
+ * @returns Promise resolving to true if the script is registered
+ */
+export declare function isScriptRegistered(id: string, appIdentifier?: string | number): Promise<boolean>;
+export {};

package/dist/driver/script-manager.js

@@ -19,8 +19,8 @@ import { ensureSessionAndConnect } from './plugin-client.js';
  * @param windowLabel - Optional window label to target
  * @returns Promise resolving to registration result
  */
-export async function registerScript(id, type, content, windowLabel) {
-    const client = await ensureSessionAndConnect();
+export async function registerScript(id, type, content, windowLabel, appIdentifier) {
+    const client = await ensureSessionAndConnect(appIdentifier);
     const response = await client.sendCommand({
         command: 'register_script',
         args: { id, type, content, windowLabel },
@@ -37,8 +37,8 @@ export async function registerScript(id, type, content, windowLabel) {
  * @param windowLabel - Optional window label to target
  * @returns Promise resolving to removal result
  */
-export async function removeScript(id, windowLabel) {
-    const client = await ensureSessionAndConnect();
+export async function removeScript(id, windowLabel, appIdentifier) {
+    const client = await ensureSessionAndConnect(appIdentifier);
     const response = await client.sendCommand({
         command: 'remove_script',
         args: { id, windowLabel },
@@ -54,8 +54,8 @@ export async function removeScript(id, windowLabel) {
  * @param windowLabel - Optional window label to target
  * @returns Promise resolving to the number of scripts cleared
  */
-export async function clearScripts(windowLabel) {
-    const client = await ensureSessionAndConnect();
+export async function clearScripts(windowLabel, appIdentifier) {
+    const client = await ensureSessionAndConnect(appIdentifier);
     const response = await client.sendCommand({
         command: 'clear_scripts',
         args: { windowLabel },
@@ -70,8 +70,8 @@ export async function clearScripts(windowLabel) {
  *
  * @returns Promise resolving to the list of registered scripts
  */
-export async function getScripts() {
-    const client = await ensureSessionAndConnect();
+export async function getScripts(appIdentifier) {
+    const client = await ensureSessionAndConnect(appIdentifier);
     const response = await client.sendCommand({
         command: 'get_scripts',
         args: {},
@@ -87,7 +87,7 @@ export async function getScripts() {
  * @param id - The script ID to check
  * @returns Promise resolving to true if the script is registered
  */
-export async function isScriptRegistered(id) {
-    const { scripts } = await getScripts();
+export async function isScriptRegistered(id, appIdentifier) {
+    const { scripts } = await getScripts(appIdentifier);
     return scripts.some((s) => { return s.id === id; });
 }

package/dist/driver/scripts/aria-api-loader.d.ts

@@ -0,0 +1,17 @@
+/**
+ * aria-api library loader
+ *
+ * Bundles aria-api for browser injection. Provides comprehensive W3C-compliant
+ * accessibility computation including:
+ * - WAI-ARIA 1.3 role computation
+ * - HTML-AAM 1.0 implicit role mappings
+ * - Accessible Name and Description Computation 1.2
+ * - aria-owns relationship handling
+ */
+/** Script ID used for the aria-api library in the script registry. */
+export declare const ARIA_API_SCRIPT_ID = "__mcp_aria_api__";
+/**
+ * Get the aria-api library source code.
+ * Loaded lazily and cached.
+ */
+export declare function getAriaApiSource(): string;

package/dist/driver/scripts/html2canvas-loader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * html2canvas-pro library loader
+ *
+ * Loads the html2canvas-pro library from node_modules and provides it as a string
+ * that can be injected into the webview. html2canvas-pro is a fork of html2canvas
+ * that adds support for modern CSS color functions like oklch(), oklab(), lab(),
+ * lch(), and color().
+ */
+/** Script ID used for the html2canvas library in the script registry. */
+export declare const HTML2CANVAS_SCRIPT_ID = "__mcp_html2canvas__";
+/**
+ * Get the html2canvas-pro library source code.
+ * Loaded lazily and cached.
+ */
+export declare function getHtml2CanvasSource(): string;
+/**
+ * Build a script that captures a screenshot using html2canvas.
+ * Assumes html2canvas is already loaded (either via script manager or inline).
+ */
+export declare function buildScreenshotCaptureScript(format: 'png' | 'jpeg', quality: number): string;
+/**
+ * Build a script that injects html2canvas and captures a screenshot.
+ * This is the legacy function that inlines the library - kept for fallback.
+ */
+export declare function buildScreenshotScript(format: 'png' | 'jpeg', quality: number): string;

package/dist/driver/scripts/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+export declare const SCRIPTS: {
+    readonly resolveRef: string;
+    readonly interact: string;
+    readonly swipe: string;
+    readonly keyboard: string;
+    readonly waitFor: string;
+    readonly getStyles: string;
+    readonly focus: string;
+    readonly findElement: string;
+    readonly domSnapshot: string;
+    readonly elementPicker: string;
+};
+/** Script ID used for resolve-ref in the script registry. */
+export declare const RESOLVE_REF_SCRIPT_ID = "__mcp_resolve_ref__";
+/**
+ * Get the resolve-ref script source code.
+ */
+export declare function getResolveRefSource(): string;
+/**
+ * Build a script invocation with parameters
+ * The script should be an IIFE that accepts a params object
+ */
+export declare function buildScript(script: string, params: Record<string, unknown>): string;
+/**
+ * Build a script for typing text (uses the keyboard script's typeText function)
+ */
+export declare function buildTypeScript(selector: string, text: string, strategy?: string): string;
+/**
+ * Build a script for key events (press, down, up)
+ */
+export declare function buildKeyEventScript(action: string, key: string, modifiers?: string[]): string;

package/dist/driver/scripts/index.js

@@ -56,8 +56,24 @@ export function buildTypeScript(selector, text, strategy) {
          if (!element) throw new Error('Element not found: ' + selector);
 
          element.focus();
-         element.value = text;
-         element.dispatchEvent(new Event('input', { bubbles: true }));
+
+         // Use native prototype setter to bypass React's value tracker
+         var proto = element.tagName === 'TEXTAREA'
+            ? HTMLTextAreaElement.prototype
+            : HTMLInputElement.prototype;
+         var descriptor = Object.getOwnPropertyDescriptor(proto, 'value');
+
+         if (descriptor && descriptor.set) {
+            descriptor.set.call(element, text);
+         } else {
+            element.value = text;
+         }
+
+         // Reset React's internal value tracker so it detects the change
+         if (element._valueTracker) element._valueTracker.setValue('');
+
+         // Dispatch proper InputEvent (not generic Event) for React compatibility
+         element.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: text }));
          element.dispatchEvent(new Event('change', { bubbles: true }));
 
          var msg = 'Typed "' + text + '" into ' + selector;

package/dist/driver/scripts/resolve-ref.js

@@ -47,9 +47,22 @@
       }
 
       if (strategy === 'text') {
+         // First try: match element text content
          var xpath = xpathForText(selectorOrRef);
          var result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-         return result.singleNodeValue;
+         if (result.singleNodeValue) return result.singleNodeValue;
+
+         // Fallback: search placeholder, aria-label, and title attributes
+         var attrSelectors = [
+            '[placeholder*="' + selectorOrRef.replace(/"/g, '\\"') + '"]',
+            '[aria-label*="' + selectorOrRef.replace(/"/g, '\\"') + '"]',
+            '[title*="' + selectorOrRef.replace(/"/g, '\\"') + '"]',
+         ];
+         for (var i = 0; i < attrSelectors.length; i++) {
+            var el = document.querySelector(attrSelectors[i]);
+            if (el) return el;
+         }
+         return null;
       }
 
       if (strategy === 'xpath') {
@@ -78,12 +91,25 @@
       }
 
       if (strategy === 'text') {
+         // First try: match element text content
          var xpath = xpathForText(selector);
          var snapshot = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
          var results = [];
          for (var i = 0; i < snapshot.snapshotLength; i++) {
             results.push(snapshot.snapshotItem(i));
          }
+         if (results.length > 0) return results;
+
+         // Fallback: search placeholder, aria-label, and title attributes
+         var attrSelectors = [
+            '[placeholder*="' + selector.replace(/"/g, '\\"') + '"]',
+            '[aria-label*="' + selector.replace(/"/g, '\\"') + '"]',
+            '[title*="' + selector.replace(/"/g, '\\"') + '"]',
+         ];
+         for (var i = 0; i < attrSelectors.length; i++) {
+            var found = Array.from(document.querySelectorAll(attrSelectors[i]));
+            if (found.length > 0) return results.concat(found);
+         }
          return results;
       }
 

package/dist/driver/session-manager.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { PluginClient } from './plugin-client.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
+ */
+export declare const ManageDriverSessionSchema: z.ZodObject<{
+    action: z.ZodEnum<["start", "stop", "status"]>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    action: "status" | "start" | "stop";
+    host?: string | undefined;
+    port?: number | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    action: "status" | "start" | "stop";
+    host?: string | undefined;
+    port?: number | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export interface SessionInfo {
+    name: string;
+    identifier: string | null;
+    host: string;
+    port: number;
+    client: PluginClient;
+    connected: boolean;
+}
+/**
+ * Check if any session is currently active.
+ * @returns true if at least one session exists
+ */
+export declare function hasActiveSession(): boolean;
+/**
+ * Get a specific session by port.
+ */
+export declare function getSession(port: number): SessionInfo | null;
+/**
+ * Get the default session (most recently connected).
+ */
+export declare function getDefaultSession(): SessionInfo | null;
+/**
+ * Get all active sessions.
+ */
+export declare function getAllSessions(): SessionInfo[];
+/**
+ * Resolve target app from port or identifier.
+ * Returns the appropriate session based on the routing logic.
+ */
+export declare function resolveTargetApp(portOrIdentifier?: string | number): SessionInfo;
+/**
+ * Manage session lifecycle (start, stop, or status).
+ *
+ * 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', 'stop', or 'status'
+ * @param host - Optional host address (defaults to env var or localhost)
+ * @param port - Optional port number (defaults to 9223)
+ * @param appIdentifier - Optional app identifier for 'stop' action (port or bundle ID)
+ * @returns For 'start'/'stop': A message string describing the result.
+ *          For 'status': A JSON string with connection details
+ */
+export declare function manageDriverSession(action: 'start' | 'stop' | 'status', host?: string, port?: number, appIdentifier?: string | number): Promise<string>;

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

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+/**
+ * Ensures the MCP server is fully initialized and ready to use.
+ * This is called automatically by all tool functions.
+ *
+ * Initialization includes:
+ * - Verifying an active session exists (via driver_session)
+ * - Connecting to the plugin WebSocket using session config
+ * - Console capture is already initialized by bridge.js in the Tauri app
+ *
+ * This function is idempotent - calling it multiple times is safe.
+ *
+ * @throws Error if no session is active (driver_session must be called first)
+ */
+export declare function ensureReady(windowId?: string, appIdentifier?: string | number): Promise<void>;
+/**
+ * Reset initialization state (useful for testing or reconnecting).
+ */
+export declare function resetInitialization(): void;
+export interface ExecuteInWebviewResult {
+    result: string;
+    windowLabel: string;
+    warning?: string;
+}
+/**
+ * Execute JavaScript in the Tauri webview using native IPC via WebSocket.
+ *
+ * @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
+ * @returns Result of the script execution with window context
+ */
+export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | 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
+ * @returns Result of the script execution with window context
+ */
+export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number): Promise<ExecuteInWebviewResult>;
+/**
+ * Execute async JavaScript in the webview with timeout support.
+ *
+ * @param script - JavaScript code to execute (can use await)
+ * @param windowId - Optional window label to target (defaults to "main")
+ * @param timeout - Timeout in milliseconds (default: 5000)
+ * @returns Result of the script execution
+ */
+export declare function executeAsyncInWebview(script: string, windowId?: string, timeout?: number, appIdentifier?: string | number): Promise<string>;
+/**
+ * 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 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
+ * @returns Formatted console logs as string
+ */
+export declare function getConsoleLogs(filter?: string, since?: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+/**
+ * Clear all captured console logs.
+ */
+export declare function clearConsoleLogs(): Promise<string>;
+import type { ToolContent } from '../tools-registry.js';
+/**
+ * Result of a screenshot capture, containing both image data and optional context.
+ */
+export interface ScreenshotResult {
+    content: ToolContent[];
+}
+export interface CaptureScreenshotOptions {
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+    maxWidth?: number;
+}
+/**
+ * Capture a screenshot of the entire webview.
+ *
+ * @param options - Screenshot options (format, quality, windowId, appIdentifier, etc.)
+ * @returns Screenshot result with image content
+ */
+export declare function captureScreenshot(options?: CaptureScreenshotOptions): Promise<ScreenshotResult>;
+export declare const ExecuteScriptSchema: z.ZodObject<{
+    script: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    script: string;
+}, {
+    script: string;
+}>;
+export declare const GetConsoleLogsSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    since?: string | undefined;
+}, {
+    filter?: string | undefined;
+    since?: string | undefined;
+}>;
+export declare const CaptureScreenshotSchema: z.ZodObject<{
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
+    quality: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    format: "png" | "jpeg";
+    quality?: number | undefined;
+}, {
+    format?: "png" | "jpeg" | undefined;
+    quality?: number | undefined;
+}>;

package/dist/driver/webview-executor.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
-import { connectPlugin } from './plugin-client.js';
-import { hasActiveSession, getDefaultSession, resolveTargetApp } from './session-manager.js';
+import { hasActiveSession, resolveTargetApp, manageDriverSession } from './session-manager.js';
 import { createMcpLogger } from '../logger.js';
 import { buildScreenshotScript, buildScreenshotCaptureScript, getHtml2CanvasSource, HTML2CANVAS_SCRIPT_ID, } from './scripts/html2canvas-loader.js';
 import { registerScript, isScriptRegistered } from './script-manager.js';
@@ -17,7 +16,7 @@ import { getResolveRefSource, RESOLVE_REF_SCRIPT_ID } from './scripts/index.js';
 // ============================================================================
 // Auto-Initialization System
 // ============================================================================
-let isInitialized = false;
+const initializedTargets = new Set();
 const driverLogger = createMcpLogger('DRIVER');
 /**
  * Ensures the MCP server is fully initialized and ready to use.
@@ -32,28 +31,52 @@ const driverLogger = createMcpLogger('DRIVER');
  *
  * @throws Error if no session is active (driver_session must be called first)
  */
-export async function ensureReady() {
-    if (isInitialized) {
-        return;
-    }
-    // Require an active session to prevent connecting to wrong app
+export async function ensureReady(windowId, appIdentifier) {
+    // Auto-connect if no active session
     if (!hasActiveSession()) {
-        throw new Error('No active session. Call driver_session with action "start" first to connect to a Tauri app.');
+        const result = await manageDriverSession('start');
+        if (!hasActiveSession()) {
+            throw new Error('Auto-connect failed: ' + result + '. Call driver_session with action "start" to connect manually.');
+        }
     }
-    // Get default session for initial connection
-    const session = getDefaultSession();
-    if (session) {
-        await connectPlugin(session.host, session.port);
+    const session = resolveTargetApp(appIdentifier);
+    if (!session.client.isConnected()) {
+        await session.client.connect();
     }
-    // Register the resolve-ref helper so ref-based selectors work in all tools
-    await registerScript(RESOLVE_REF_SCRIPT_ID, 'inline', getResolveRefSource());
-    isInitialized = true;
+    const targetKey = `${session.host}:${session.port}:${windowId ?? 'main'}`;
+    if (initializedTargets.has(targetKey)) {
+        return;
+    }
+    // Register the resolve-ref helper in the target window
+    // so ref-based selectors work there.
+    await registerScript(RESOLVE_REF_SCRIPT_ID, 'inline', getResolveRefSource(), windowId, appIdentifier);
+    await waitForResolveRefHelper(session, windowId);
+    initializedTargets.add(targetKey);
 }
 /**
  * Reset initialization state (useful for testing or reconnecting).
  */
 export function resetInitialization() {
-    isInitialized = false;
+    initializedTargets.clear();
+}
+async function waitForResolveRefHelper(session, windowId) {
+    if (!session) {
+        throw new Error('No active session available while registering resolve-ref helper.');
+    }
+    for (let attempt = 0; attempt < 20; attempt++) {
+        const response = await session.client.sendCommand({
+            command: 'execute_js',
+            args: {
+                script: 'return !!(window.__MCP__ && typeof window.__MCP__.resolveRef === "function")',
+                windowLabel: windowId,
+            },
+        }, 2000);
+        if (response.success && response.data === true) {
+            return;
+        }
+        await new Promise((resolve) => { return setTimeout(resolve, 50); });
+    }
+    throw new Error('Resolve-ref helper was not available in the webview after registration.');
 }
 /**
  * Execute JavaScript in the Tauri webview using native IPC via WebSocket.
@@ -78,7 +101,7 @@ export async function executeInWebview(script, windowId, appIdentifier) {
 export async function executeInWebviewWithContext(script, windowId, appIdentifier) {
     try {
         // Ensure we're fully initialized
-        await ensureReady();
+        await ensureReady(windowId, appIdentifier);
         // Resolve target session
         const session = resolveTargetApp(appIdentifier);
         const client = session.client;
@@ -124,11 +147,12 @@ export async function executeInWebviewWithContext(script, windowId, appIdentifie
  * @param timeout - Timeout in milliseconds (default: 5000)
  * @returns Result of the script execution
  */
-export async function executeAsyncInWebview(script, windowId, timeout = 5000) {
+export async function executeAsyncInWebview(script, windowId, timeout, appIdentifier) {
+    const resolvedTimeout = timeout ?? 5000;
     const wrappedScript = `
       return (async () => {
          const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error('Script execution timeout')), ${timeout});
+            setTimeout(() => reject(new Error('Script execution timeout')), ${resolvedTimeout});
          });
 
          const scriptPromise = (async () => {
@@ -138,7 +162,7 @@ export async function executeAsyncInWebview(script, windowId, timeout = 5000) {
          return await Promise.race([scriptPromise, timeoutPromise]);
       })();
    `;
-    return executeInWebview(wrappedScript, windowId);
+    return executeInWebview(wrappedScript, windowId, appIdentifier);
 }
 // ============================================================================
 // Console Log Capture System
@@ -268,14 +292,14 @@ function buildScreenshotResult(dataUrl, method, windowContext) {
  * Prepares the html2canvas script for screenshot capture.
  * Tries to use the script manager for persistence, falls back to inline injection.
  */
-async function prepareHtml2canvasScript(format, quality) {
+async function prepareHtml2canvasScript(format, quality, windowId, appIdentifier) {
     try {
         // Check if html2canvas is already registered
-        const isRegistered = await isScriptRegistered(HTML2CANVAS_SCRIPT_ID);
+        const isRegistered = await isScriptRegistered(HTML2CANVAS_SCRIPT_ID, appIdentifier);
         if (!isRegistered) {
             // Register html2canvas via script manager for persistence across navigations
             const html2canvasSource = getHtml2CanvasSource();
-            await registerScript(HTML2CANVAS_SCRIPT_ID, 'inline', html2canvasSource);
+            await registerScript(HTML2CANVAS_SCRIPT_ID, 'inline', html2canvasSource, windowId, appIdentifier);
         }
         // Use the capture-only script since html2canvas is now registered
         return buildScreenshotCaptureScript(format, quality);
@@ -299,7 +323,7 @@ export async function captureScreenshot(options = {}) {
     // - Linux: Chromium/WebKit screenshot APIs
     try {
         // Ensure we're fully initialized
-        await ensureReady();
+        await ensureReady(windowId, appIdentifier);
         // Resolve target session
         const session = resolveTargetApp(appIdentifier);
         const client = session.client;
@@ -331,7 +355,7 @@ export async function captureScreenshot(options = {}) {
     }
     // 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);
+    const html2canvasScript = await prepareHtml2canvasScript(format, quality, windowId, appIdentifier);
     // Fallback: Try Screen Capture API if available
     // Note: This script is wrapped by executeAsyncInWebview, so we don't need an IIFE
     const screenCaptureScript = `
@@ -390,7 +414,7 @@ export async function captureScreenshot(options = {}) {
    `;
     try {
         // Try html2canvas second (after native APIs)
-        const result = await executeAsyncInWebview(html2canvasScript, undefined, 10000); // Longer timeout for library loading
+        const result = await executeAsyncInWebview(html2canvasScript, windowId, 10000, appIdentifier);
         // Validate that we got a real data URL, not 'null' or empty
         if (result && result !== 'null' && result.startsWith('data:image/')) {
             return buildScreenshotResult(result, 'html2canvas');
@@ -400,7 +424,7 @@ export async function captureScreenshot(options = {}) {
     catch (html2canvasError) {
         try {
             // Fallback to Screen Capture API
-            const result = await executeAsyncInWebview(screenCaptureScript);
+            const result = await executeAsyncInWebview(screenCaptureScript, windowId, 5000, appIdentifier);
             // Validate that we got a real data URL
             if (result && result.startsWith('data:image/')) {
                 return buildScreenshotResult(result, 'Screen Capture API');