MCP Server Tauri

Instructions

Implementation Reference

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

  Core handler function that builds the wait script using buildScript and SCRIPTS.waitFor, then executes it in the target webview window via executeInWebview.

  export async function waitFor(options: WaitForOptions): Promise<string> {
     const { type, value, timeout = 5000, windowId, appIdentifier } = options;
  
     const script = buildScript(SCRIPTS.waitFor, { type, value, timeout });
  
     try {
        return await executeInWebview(script, windowId, appIdentifier);
     } catch(error: unknown) {
        const message = error instanceof Error ? error.message : String(error);
  
        throw new Error(`Wait failed: ${message}`);
     }
  }

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

  Zod schema for validating input parameters: type (selector/text/ipc-event), value, timeout, plus inherited windowId/appIdentifier.

  export const WaitForSchema = WindowTargetSchema.extend({
     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)'),
  });

• packages/mcp-server/src/tools-registry.ts:395-420 (registration)

  Tool registration in the central TOOLS array, including description, category, schema reference, annotations, and thin wrapper handler that parses args and delegates to the waitFor implementation.

  {
     name: 'tauri_webview_wait_for',
     description:
        '[Tauri Apps Only] Wait for elements, text, or IPC events in a Tauri app. ' +
        'Requires active tauri_driver_session. ' +
        MULTI_APP_DESC + ' ' +
        'For browser waits, use Chrome DevTools MCP instead.',
     category: TOOL_CATEGORIES.UI_AUTOMATION,
     schema: WaitForSchema,
     annotations: {
        title: 'Wait for Condition in Tauri',
        readOnlyHint: true,
        openWorldHint: false,
     },
     handler: async (args) => {
        const parsed = WaitForSchema.parse(args);
  
        return await waitFor({
           type: parsed.type,
           value: parsed.value,
           timeout: parsed.timeout,
           windowId: parsed.windowId,
           appIdentifier: parsed.appIdentifier,
        });
     },
  },

• packages/mcp-server/src/driver/scripts/wait-for.js:1-45 (helper)

  Injected JavaScript script (SCRIPTS.waitFor) that implements the polling logic: checks every 100ms for selector existence or text presence in document.body.innerText, resolves with success message or rejects on timeout.

  /**
   * Wait for conditions script - waits for selectors, text, or events
   *
   * @param {Object} params
   * @param {string} params.type - What to wait for: 'selector', 'text', 'ipc-event'
   * @param {string} params.value - Selector, text, or event name to wait for
   * @param {number} params.timeout - Timeout in milliseconds
   */
  (async function(params) {
     const { type, value, timeout } = params;
     const startTime = Date.now();
  
     return new Promise((resolve, reject) => {
        function check() {
           if (Date.now() - startTime > timeout) {
              reject(new Error(`Timeout waiting for ${type}: ${value}`));
              return;
           }
  
           if (type === 'selector') {
              const element = document.querySelector(value);
              if (element) {
                 resolve(`Element found: ${value}`);
                 return;
              }
           } else if (type === 'text') {
              const found = document.body.innerText.includes(value);
              if (found) {
                 resolve(`Text found: ${value}`);
                 return;
              }
           } else if (type === 'ipc-event') {
              // For IPC events, we'd need to set up a listener
              // This is a simplified version
              reject(new Error('IPC event waiting not yet implemented in this context'));
              return;
           }
  
           setTimeout(check, 100);
        }
  
        check();
     });
  })