@hypothesi/tauri-mcp-server 0.5.1 → 0.6.2

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@hypothesi/tauri-mcp-server)](https://www.npmjs.com/package/@hypothesi/tauri-mcp-server)
 [![License: MIT](https://img.shields.io/badge/License-MIT-8b5cf6.svg)](https://github.com/hypothesi/mcp-server-tauri/blob/main/LICENSE)
 
-A **Model Context Protocol (MCP) server** that enables AI assistants like Claude, Cursor, and Windsurf to build, test, and debug Tauri v2 applications.
+A **Model Context Protocol (MCP) server** that enables AI assistants like Claude, Cursor, and Windsurf to build, test, and debug Tauri® v2 applications.
 
 📖 **[Full Documentation](https://hypothesi.github.io/mcp-server-tauri)**
 
@@ -52,6 +52,40 @@ npx -y install-mcp @hypothesi/tauri-mcp-server --client claude-code
 
 Supported clients: `claude-code`, `cursor`, `windsurf`, `vscode`, `cline`, `roo-cline`, `claude`, `zed`, `goose`, `warp`, `codex`
 
+## Multi-App Support
+
+The MCP server supports connecting to multiple Tauri apps simultaneously. Each app runs on a unique port, and the most recently connected app becomes the "default" app.
+
+**Key Features:**
+- Connect to multiple apps on different ports
+- Default app used when no `appIdentifier` specified
+- Target specific apps using port number or bundle ID
+- Stop individual sessions or all sessions at once
+
+**Example Usage:**
+```javascript
+// Connect to first app
+await tauri_driver_session({ action: "start", port: 9223 })
+
+// Connect to second app
+await tauri_driver_session({ action: "start", port: 9224 })
+
+// Check status - shows both apps with default indicator
+await tauri_driver_session({ action: "status" })
+
+// Use default app (most recent - port 9224)
+await tauri_webview_screenshot()
+
+// Target specific app by port
+await tauri_webview_screenshot({ appIdentifier: 9223 })
+
+// Stop specific app
+await tauri_driver_session({ action: "stop", appIdentifier: 9223 })
+
+// Stop all apps
+await tauri_driver_session({ action: "stop" })
+```
+
 ## Available Tools (16 total)
 
 ### UI Automation
@@ -95,3 +129,11 @@ Supported clients: `claude-code`, `cursor`, `windsurf`, `vscode`, `cline`, `roo-
 ## License
 
 MIT © [hypothesi](https://github.com/hypothesi)
+
+---
+
+## Trademark Notice
+
+TAURI® is a registered trademark of The Tauri Programme within the Commons Conservancy. [https://tauri.app/](https://tauri.app/)
+
+This project is not affiliated with, endorsed by, or sponsored by The Tauri Programme within the Commons Conservancy.

package/dist/driver/plugin-client.js

@@ -225,20 +225,18 @@ export async function connectPlugin(host, port) {
  * Ensures a session is active and connects to the plugin using session config.
  * This should be used by all tools that require a connected Tauri app.
  *
+ * @param appIdentifier - Optional app identifier to target specific app
  * @throws Error if no session is active
  */
-export async function ensureSessionAndConnect() {
+export async function ensureSessionAndConnect(appIdentifier) {
     // Import dynamically to avoid circular dependency
-    const { hasActiveSession, getCurrentSession } = await import('./session-manager.js');
-    if (!hasActiveSession()) {
-        throw new Error('No active session. Call tauri_driver_session with action "start" first to connect to a Tauri app.');
+    const { resolveTargetApp } = await import('./session-manager.js');
+    const session = resolveTargetApp(appIdentifier);
+    // Ensure client is connected
+    if (!session.client.isConnected()) {
+        await session.client.connect();
     }
-    const session = getCurrentSession();
-    if (!session) {
-        throw new Error('Session state is inconsistent. Please restart the session.');
-    }
-    await connectPlugin(session.host, session.port);
-    return getPluginClient(session.host, session.port);
+    return session.client;
 }
 export async function disconnectPlugin() {
     const client = getPluginClient();

package/dist/driver/plugin-commands.js

@@ -3,11 +3,13 @@ import { ensureSessionAndConnect, getExistingPluginClient } from './plugin-clien
 export const ExecuteIPCCommandSchema = z.object({
     command: z.string(),
     args: z.unknown().optional(),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
-export async function executeIPCCommand(command, args = {}) {
+export async function executeIPCCommand(options) {
     try {
+        const { command, args = {}, appIdentifier } = options;
         // Ensure we have an active session and are connected
-        const client = await ensureSessionAndConnect();
+        const client = await ensureSessionAndConnect(appIdentifier);
         // Send IPC command via WebSocket to the mcp-bridge plugin
         const response = await client.sendCommand({
             command: 'invoke_tauri',
@@ -26,19 +28,20 @@ export async function executeIPCCommand(command, args = {}) {
 // Combined schema for managing IPC monitoring
 export const ManageIPCMonitoringSchema = z.object({
     action: z.enum(['start', 'stop']).describe('Action to perform: start or stop IPC monitoring'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
 // Keep individual schemas for backward compatibility if needed
 export const StartIPCMonitoringSchema = z.object({});
 export const StopIPCMonitoringSchema = z.object({});
-export async function manageIPCMonitoring(action) {
+export async function manageIPCMonitoring(action, appIdentifier) {
     if (action === 'start') {
-        return startIPCMonitoring();
+        return startIPCMonitoring(appIdentifier);
     }
-    return stopIPCMonitoring();
+    return stopIPCMonitoring(appIdentifier);
 }
-export async function startIPCMonitoring() {
+export async function startIPCMonitoring(appIdentifier) {
     try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|start_ipc_monitor');
+        const result = await executeIPCCommand({ command: 'plugin:mcp-bridge|start_ipc_monitor', appIdentifier });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
             throw new Error(parsed.error || 'Unknown error');
@@ -50,9 +53,9 @@ export async function startIPCMonitoring() {
         throw new Error(`Failed to start IPC monitoring: ${message}`);
     }
 }
-export async function stopIPCMonitoring() {
+export async function stopIPCMonitoring(appIdentifier) {
     try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|stop_ipc_monitor');
+        const result = await executeIPCCommand({ command: 'plugin:mcp-bridge|stop_ipc_monitor', appIdentifier });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
             throw new Error(parsed.error || 'Unknown error');
@@ -66,10 +69,11 @@ export async function stopIPCMonitoring() {
 }
 export const GetIPCEventsSchema = z.object({
     filter: z.string().optional().describe('Filter events by command name'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
-export async function getIPCEvents(filter) {
+export async function getIPCEvents(filter, appIdentifier) {
     try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|get_ipc_events');
+        const result = await executeIPCCommand({ command: 'plugin:mcp-bridge|get_ipc_events', appIdentifier });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
             throw new Error(parsed.error || 'Unknown error');
@@ -91,12 +95,17 @@ export async function getIPCEvents(filter) {
 export const EmitTestEventSchema = z.object({
     eventName: z.string(),
     payload: z.unknown(),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
-export async function emitTestEvent(eventName, payload) {
+export async function emitTestEvent(eventName, payload, appIdentifier) {
     try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|emit_event', {
-            eventName,
-            payload,
+        const result = await executeIPCCommand({
+            command: 'plugin:mcp-bridge|emit_event',
+            args: {
+                eventName,
+                payload,
+            },
+            appIdentifier,
         });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
@@ -109,10 +118,12 @@ export async function emitTestEvent(eventName, payload) {
         throw new Error(`Failed to emit event: ${message}`);
     }
 }
-export const GetWindowInfoSchema = z.object({});
-export async function getWindowInfo() {
+export const GetWindowInfoSchema = z.object({
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
+});
+export async function getWindowInfo(appIdentifier) {
     try {
-        const result = await executeIPCCommand('plugin:mcp-bridge|get_window_info');
+        const result = await executeIPCCommand({ command: 'plugin:mcp-bridge|get_window_info', appIdentifier });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
             throw new Error(parsed.error || 'Unknown error');
@@ -124,7 +135,9 @@ export async function getWindowInfo() {
         throw new Error(`Failed to get window info: ${message}`);
     }
 }
-export const GetBackendStateSchema = z.object({});
+export const GetBackendStateSchema = z.object({
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
+});
 /**
  * Get backend state from the connected Tauri app.
  *
@@ -135,8 +148,9 @@ export const GetBackendStateSchema = z.object({});
  * @param useExistingClient If true, uses the existing connected client without
  *        session validation. Used during session setup before currentSession is set.
  */
-export async function getBackendState(useExistingClient = false) {
+export async function getBackendState(options = {}) {
     try {
+        const { useExistingClient = false, appIdentifier } = options;
         if (useExistingClient) {
             // During session setup, use the already-connected client directly
             const client = getExistingPluginClient();
@@ -153,7 +167,7 @@ export async function getBackendState(useExistingClient = false) {
             return JSON.stringify(response.data);
         }
         // Normal mode: use executeIPCCommand which validates session
-        const result = await executeIPCCommand('plugin:mcp-bridge|get_backend_state');
+        const result = await executeIPCCommand({ command: 'plugin:mcp-bridge|get_backend_state', appIdentifier });
         const parsed = JSON.parse(result);
         if (!parsed.success) {
             throw new Error(parsed.error || 'Unknown error');
@@ -172,9 +186,9 @@ export const ListWindowsSchema = z.object({});
 /**
  * Lists all open webview windows in the Tauri application.
  */
-export async function listWindows() {
+export async function listWindows(appIdentifier) {
     try {
-        const client = await ensureSessionAndConnect();
+        const client = await ensureSessionAndConnect(appIdentifier);
         const response = await client.sendCommand({
             command: 'list_windows',
         });
@@ -208,7 +222,7 @@ export const ResizeWindowSchema = z.object({
  */
 export async function resizeWindow(options) {
     try {
-        const client = await ensureSessionAndConnect();
+        const client = await ensureSessionAndConnect(options.appIdentifier);
         const response = await client.sendCommand({
             command: 'resize_window',
             args: {
@@ -239,6 +253,7 @@ export const ManageWindowSchema = z.object({
         .describe('Height in pixels (required for "resize" action)'),
     logical: z.boolean().optional().default(true)
         .describe('Use logical pixels (true, default) or physical pixels (false). Only for "resize"'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
 /**
  * Unified window management function.
@@ -252,14 +267,14 @@ export const ManageWindowSchema = z.object({
  * @returns JSON string with the result
  */
 export async function manageWindow(options) {
-    const { action, windowId, width, height, logical } = options;
+    const { action, windowId, width, height, logical, appIdentifier } = options;
     switch (action) {
         case 'list': {
-            return listWindows();
+            return listWindows(appIdentifier);
         }
         case 'info': {
             try {
-                const client = await ensureSessionAndConnect();
+                const client = await ensureSessionAndConnect(appIdentifier);
                 const response = await client.sendCommand({
                     command: 'get_window_info',
                     args: { windowId },
@@ -278,7 +293,7 @@ export async function manageWindow(options) {
             if (width === undefined || height === undefined) {
                 throw new Error('width and height are required for resize action');
             }
-            return resizeWindow({ width, height, windowId, logical });
+            return resizeWindow({ width, height, windowId, logical, appIdentifier });
         }
         default: {
             throw new Error(`Unknown action: ${action}`);

package/dist/driver/session-manager.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { getDefaultHost, getDefaultPort } from '../config.js';
 import { AppDiscovery } from './app-discovery.js';
-import { resetPluginClient, getExistingPluginClient, connectPlugin } from './plugin-client.js';
-import { getBackendState } from './plugin-commands.js';
+import { PluginClient } from './plugin-client.js';
 import { resetInitialization } from './webview-executor.js';
+import { createMcpLogger } from '../logger.js';
+const sessionLogger = createMcpLogger('SESSION');
 /**
  * Session Manager - Native IPC-based session management
  *
@@ -22,25 +23,45 @@ export const ManageDriverSessionSchema = z.object({
     action: z.enum(['start', 'stop', 'status']).describe('Action to perform: start or stop the session, or check status'),
     host: z.string().optional().describe('Host address to connect to (e.g., 192.168.1.100). Falls back to MCP_BRIDGE_HOST or TAURI_DEV_HOST env vars'),
     port: z.number().optional().describe('Port to connect to (default: 9223)'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App identifier (port number or bundle ID) to stop. Only used with action "stop". If omitted, stops all sessions.'),
 });
 // ============================================================================
 // Module State
 // ============================================================================
 // AppDiscovery instance - recreated when host changes
-// Track current session info including app identifier for session reuse
-let appDiscovery = null, currentSession = null;
+let appDiscovery = null;
+// Track multiple concurrent sessions keyed by port
+const activeSessions = new Map();
+// Track the default app (most recently connected)
+let defaultPort = null;
 /**
- * Check if a session is currently active.
- * @returns true if a session has been started and not stopped
+ * Check if any session is currently active.
+ * @returns true if at least one session exists
  */
 export function hasActiveSession() {
-    return currentSession !== null;
+    return activeSessions.size > 0;
 }
 /**
- * Get the current session info, or null if no session is active.
+ * Get a specific session by port.
  */
-export function getCurrentSession() {
-    return currentSession;
+export function getSession(port) {
+    return activeSessions.get(port) ?? null;
+}
+/**
+ * Get the default session (most recently connected).
+ */
+export function getDefaultSession() {
+    if (defaultPort !== null && activeSessions.has(defaultPort)) {
+        const session = activeSessions.get(defaultPort);
+        return session ?? null;
+    }
+    return null;
+}
+/**
+ * Get all active sessions.
+ */
+export function getAllSessions() {
+    return Array.from(activeSessions.values());
 }
 function getAppDiscovery(host) {
     if (!appDiscovery || appDiscovery.host !== host) {
@@ -48,6 +69,208 @@ function getAppDiscovery(host) {
     }
     return appDiscovery;
 }
+/**
+ * Resolve target app from port or identifier.
+ * Returns the appropriate session based on the routing logic.
+ */
+export function resolveTargetApp(portOrIdentifier) {
+    if (activeSessions.size === 0) {
+        throw new Error('No active session. Call tauri_driver_session with action "start" first to connect to a Tauri app.');
+    }
+    // Single app - return it
+    if (activeSessions.size === 1) {
+        const session = activeSessions.values().next().value;
+        if (!session) {
+            throw new Error('Session state inconsistent');
+        }
+        return session;
+    }
+    // Multiple apps - need identifier or use default
+    if (portOrIdentifier !== undefined) {
+        // Try port lookup first
+        const port = typeof portOrIdentifier === 'number'
+            ? portOrIdentifier
+            : parseInt(String(portOrIdentifier), 10);
+        if (!isNaN(port) && activeSessions.has(port)) {
+            const session = activeSessions.get(port);
+            if (session) {
+                return session;
+            }
+        }
+        // Try identifier match
+        for (const session of activeSessions.values()) {
+            if (session.identifier === String(portOrIdentifier)) {
+                return session;
+            }
+        }
+        throw new Error(formatAppNotFoundError(portOrIdentifier));
+    }
+    // Use default app
+    if (defaultPort !== null && activeSessions.has(defaultPort)) {
+        const session = activeSessions.get(defaultPort);
+        if (session) {
+            return session;
+        }
+    }
+    throw new Error('No default app set. This should not happen.');
+}
+/**
+ * Format error message when app not found.
+ */
+function formatAppNotFoundError(identifier) {
+    const appList = Array.from(activeSessions.values())
+        .map((session) => {
+        const isDefault = session.port === defaultPort;
+        const defaultMarker = isDefault ? ' [DEFAULT]' : '';
+        return `  - ${session.port}: ${session.identifier || 'unknown'} (${session.host}:${session.port})${defaultMarker}`;
+    })
+        .join('\n');
+    return (`App "${identifier}" not found.\n\n` +
+        `Connected apps:\n${appList}\n\n` +
+        'Use tauri_driver_session with action "status" to list all connected apps.');
+}
+/**
+ * Promote the next default app when the current default is removed.
+ * Selects the oldest remaining session (first in insertion order).
+ */
+function promoteNextDefault() {
+    if (activeSessions.size > 0) {
+        // Get first session (oldest)
+        const firstSession = activeSessions.values().next().value;
+        if (firstSession) {
+            defaultPort = firstSession.port;
+            sessionLogger.info(`Promoted port ${defaultPort} as new default app`);
+        }
+        else {
+            defaultPort = null;
+        }
+    }
+    else {
+        defaultPort = null;
+    }
+}
+async function handleStatusAction() {
+    if (activeSessions.size === 0) {
+        return JSON.stringify({
+            connected: false,
+            app: null,
+            identifier: null,
+            host: null,
+            port: null,
+        });
+    }
+    if (activeSessions.size === 1) {
+        const session = activeSessions.values().next().value;
+        if (!session) {
+            return JSON.stringify({
+                connected: false,
+                app: null,
+                identifier: null,
+                host: null,
+                port: null,
+            });
+        }
+        return JSON.stringify({
+            connected: true,
+            app: session.name,
+            identifier: session.identifier,
+            host: session.host,
+            port: session.port,
+        });
+    }
+    const apps = Array.from(activeSessions.values()).map((session) => {
+        return {
+            name: session.name,
+            identifier: session.identifier,
+            host: session.host,
+            port: session.port,
+            isDefault: session.port === defaultPort,
+        };
+    });
+    return JSON.stringify({
+        connected: true,
+        apps,
+        totalCount: apps.length,
+        defaultPort,
+    });
+}
+async function handleStartAction(host, port) {
+    const configuredHost = host ?? getDefaultHost();
+    const configuredPort = port ?? getDefaultPort();
+    if (activeSessions.has(configuredPort)) {
+        return `Already connected to app on port ${configuredPort}`;
+    }
+    let connectedSession = null;
+    if (configuredHost !== 'localhost' && configuredHost !== '127.0.0.1') {
+        try {
+            connectedSession = await tryConnect('localhost', configuredPort);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!connectedSession) {
+        try {
+            connectedSession = await tryConnect(configuredHost, configuredPort);
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!connectedSession) {
+        const localhostDiscovery = getAppDiscovery('localhost');
+        const firstApp = await localhostDiscovery.getFirstAvailableApp();
+        if (firstApp) {
+            try {
+                connectedSession = await tryConnect('localhost', firstApp.port);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!connectedSession) {
+        return `Session start failed - no Tauri app found at localhost or ${configuredHost}:${configuredPort}`;
+    }
+    const client = new PluginClient(connectedSession.host, connectedSession.port);
+    await client.connect();
+    const identifier = await fetchAppIdentifier(client);
+    const sessionInfo = {
+        name: connectedSession.name,
+        identifier,
+        host: connectedSession.host,
+        port: connectedSession.port,
+        client,
+        connected: true,
+    };
+    activeSessions.set(connectedSession.port, sessionInfo);
+    defaultPort = connectedSession.port;
+    sessionLogger.info(`Session started: ${sessionInfo.name} (${sessionInfo.host}:${sessionInfo.port}) [DEFAULT]`);
+    return `Session started with app: ${sessionInfo.name} (${sessionInfo.host}:${sessionInfo.port}) [DEFAULT]`;
+}
+async function handleStopAction(appIdentifier) {
+    if (appIdentifier !== undefined) {
+        const session = resolveTargetApp(appIdentifier);
+        session.client.disconnect();
+        activeSessions.delete(session.port);
+        if (session.port === defaultPort) {
+            promoteNextDefault();
+        }
+        sessionLogger.info(`Session stopped: ${session.name} (${session.host}:${session.port})`);
+        return `Session stopped: ${session.name} (${session.host}:${session.port})`;
+    }
+    for (const session of activeSessions.values()) {
+        session.client.disconnect();
+    }
+    activeSessions.clear();
+    defaultPort = null;
+    if (appDiscovery) {
+        await appDiscovery.disconnectAll();
+    }
+    resetInitialization();
+    sessionLogger.info('All sessions stopped');
+    return 'All sessions stopped';
+}
 // ============================================================================
 // Session Management
 // ============================================================================
@@ -66,18 +289,24 @@ async function tryConnect(host, port) {
 }
 /**
  * Fetch the app identifier from the backend state.
- * Must be called after the singleton pluginClient is connected.
+ * Must be called after a PluginClient is connected.
  *
+ * @param client - The PluginClient to query
  * @returns The app identifier (bundle ID) or null if not available. Returns null when:
  *          - The plugin doesn't support the identifier field (older versions)
  *          - The backend state request fails
  *          - The identifier field is missing from the response
  */
-async function fetchAppIdentifier() {
+async function fetchAppIdentifier(client) {
     try {
-        // Use existing client - called during session setup before currentSession is set
-        const stateJson = await getBackendState(true);
-        const state = JSON.parse(stateJson);
+        const response = await client.sendCommand({
+            command: 'invoke_tauri',
+            args: { command: 'plugin:mcp-bridge|get_backend_state', args: {} },
+        });
+        if (!response.success || !response.data) {
+            return null;
+        }
+        const state = response.data;
         // Return null if identifier is not present (backward compat with older plugins)
         return state.app?.identifier ?? null;
     }
@@ -98,113 +327,23 @@ async function fetchAppIdentifier() {
  * @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 including:
- *          - `connected`: boolean indicating if connected
- *          - `app`: app name (or null if not connected)
- *          - `identifier`: app bundle ID (e.g., "com.example.app"), or null
- *          - `host`: connected host (or null)
- *          - `port`: connected port (or null)
+ *          For 'status': A JSON string with connection details
  */
-export async function manageDriverSession(action, host, port) {
-    // Handle status action
-    if (action === 'status') {
-        const client = getExistingPluginClient();
-        if (client?.isConnected() && currentSession) {
-            return JSON.stringify({
-                connected: true,
-                app: currentSession.name,
-                identifier: currentSession.identifier,
-                host: currentSession.host,
-                port: currentSession.port,
-            });
+export async function manageDriverSession(action, host, port, appIdentifier) {
+    switch (action) {
+        case 'status': {
+            return handleStatusAction();
         }
-        return JSON.stringify({
-            connected: false,
-            app: null,
-            identifier: null,
-            host: null,
-            port: null,
-        });
-    }
-    if (action === 'start') {
-        // Reset any existing connections to ensure fresh connection
-        if (appDiscovery) {
-            await appDiscovery.disconnectAll();
-        }
-        resetPluginClient();
-        const configuredHost = host ?? getDefaultHost();
-        const configuredPort = port ?? getDefaultPort();
-        // Strategy 1: Try localhost first (most reliable)
-        if (configuredHost !== 'localhost' && configuredHost !== '127.0.0.1') {
-            try {
-                const session = await tryConnect('localhost', configuredPort);
-                // Connect the singleton pluginClient so status checks work
-                await connectPlugin(session.host, session.port);
-                // Fetch app identifier after singleton is connected
-                const identifier = await fetchAppIdentifier();
-                currentSession = { ...session, identifier };
-                return `Session started with app: ${session.name} (localhost:${session.port})`;
-            }
-            catch {
-                // Localhost failed, will try configured host next
-            }
+        case 'start': {
+            return handleStartAction(host, port);
         }
-        // Strategy 2: Try the configured/provided host
-        try {
-            const session = await tryConnect(configuredHost, configuredPort);
-            // Connect the singleton pluginClient so status checks work
-            await connectPlugin(session.host, session.port);
-            // Fetch app identifier after singleton is connected
-            const identifier = await fetchAppIdentifier();
-            currentSession = { ...session, identifier };
-            return `Session started with app: ${session.name} (${session.host}:${session.port})`;
+        case 'stop': {
+            return handleStopAction(appIdentifier);
         }
-        catch {
-            // Configured host failed
+        default: {
+            return handleStopAction(appIdentifier);
         }
-        // Strategy 3: Auto-discover on localhost (scan port range)
-        const localhostDiscovery = getAppDiscovery('localhost');
-        const firstApp = await localhostDiscovery.getFirstAvailableApp();
-        if (firstApp) {
-            try {
-                // Reset client again to connect to discovered port
-                resetPluginClient();
-                const session = await tryConnect('localhost', firstApp.port);
-                // Connect the singleton pluginClient so status checks work
-                await connectPlugin(session.host, session.port);
-                // Fetch app identifier after singleton is connected
-                const identifier = await fetchAppIdentifier();
-                currentSession = { ...session, identifier };
-                return `Session started with app: ${session.name} (localhost:${session.port})`;
-            }
-            catch {
-                // Discovery found app but connection failed
-            }
-        }
-        // Strategy 4: Try default port on configured host as last resort
-        try {
-            resetPluginClient();
-            const session = await tryConnect(configuredHost, configuredPort);
-            // Connect the singleton pluginClient so status checks work
-            await connectPlugin(session.host, session.port);
-            // Fetch app identifier after singleton is connected
-            const identifier = await fetchAppIdentifier();
-            currentSession = { ...session, identifier };
-            return `Session started with app: ${session.name} (${session.host}:${session.port})`;
-        }
-        catch {
-            // All attempts failed
-            currentSession = null;
-            return `Session started (native IPC mode - no Tauri app found at localhost or ${configuredHost}:${configuredPort})`;
-        }
-    }
-    // Stop action - disconnect all apps and reset initialization state
-    if (appDiscovery) {
-        await appDiscovery.disconnectAll();
     }
-    resetPluginClient();
-    resetInitialization();
-    currentSession = null;
-    return 'Session stopped';
 }

package/dist/driver/webview-executor.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { getPluginClient, connectPlugin } from './plugin-client.js';
-import { hasActiveSession, getCurrentSession } from './session-manager.js';
+import { connectPlugin } from './plugin-client.js';
+import { hasActiveSession, getDefaultSession, resolveTargetApp } 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';
@@ -39,8 +39,8 @@ export async function ensureReady() {
     if (!hasActiveSession()) {
         throw new Error('No active session. Call tauri_driver_session with action "start" first to connect to a Tauri app.');
     }
-    // Get session config and connect with explicit host/port
-    const session = getCurrentSession();
+    // Get default session for initial connection
+    const session = getDefaultSession();
     if (session) {
         await connectPlugin(session.host, session.port);
     }
@@ -57,10 +57,11 @@ export function resetInitialization() {
  *
  * @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 async function executeInWebview(script, windowId) {
-    const { result } = await executeInWebviewWithContext(script, windowId);
+export async function executeInWebview(script, windowId, appIdentifier) {
+    const { result } = await executeInWebviewWithContext(script, windowId, appIdentifier);
     return result;
 }
 /**
@@ -68,18 +69,16 @@ export async function executeInWebview(script, 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
  * @returns Result of the script execution with window context
  */
-export async function executeInWebviewWithContext(script, windowId) {
+export async function executeInWebviewWithContext(script, windowId, appIdentifier) {
     try {
         // Ensure we're fully initialized
         await ensureReady();
-        // Get session config to use correct host/port
-        const session = getCurrentSession();
-        if (!session) {
-            throw new Error('No active session');
-        }
-        const client = getPluginClient(session.host, session.port);
+        // Resolve target session
+        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.
         const response = await client.sendCommand({
@@ -185,9 +184,11 @@ export async function initializeConsoleCapture() {
  *
  * @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 async function getConsoleLogs(filter, since) {
+export async function getConsoleLogs(filter, since, windowId, appIdentifier) {
     const filterStr = filter ? filter.replace(/'/g, '\\\'') : '';
     const sinceStr = since || '';
     const script = `
@@ -212,7 +213,7 @@ export async function getConsoleLogs(filter, since) {
          '[ ' + new Date(l.timestamp).toISOString() + ' ] [ ' + l.level.toUpperCase() + ' ] ' + l.message
       ).join('\\n');
    `;
-    return executeInWebview(script);
+    return executeInWebview(script, windowId, appIdentifier);
 }
 /**
  * Clear all captured console logs.
@@ -284,11 +285,11 @@ async function prepareHtml2canvasScript(format, quality) {
 /**
  * Capture a screenshot of the entire webview.
  *
- * @param options - Screenshot options (format, quality, windowId)
+ * @param options - Screenshot options (format, quality, windowId, appIdentifier)
  * @returns Screenshot result with image content
  */
 export async function captureScreenshot(options = {}) {
-    const { format = 'png', quality = 90, windowId } = options;
+    const { format = 'png', quality = 90, windowId, appIdentifier } = options;
     // Primary implementation: Use native platform-specific APIs
     // - macOS: WKWebView takeSnapshot
     // - Windows: WebView2 CapturePreview
@@ -296,7 +297,9 @@ export async function captureScreenshot(options = {}) {
     try {
         // Ensure we're fully initialized
         await ensureReady();
-        const client = getPluginClient();
+        // 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',

package/dist/driver/webview-interactions.js

@@ -7,11 +7,12 @@ import { SCRIPTS, buildScript, buildTypeScript, buildKeyEventScript } from './sc
 // Base Schema for Window Targeting
 // ============================================================================
 /**
- * Base schema mixin for tools that can target a specific window.
- * All webview tools extend this to support multi-window applications.
+ * Base schema mixin for tools that can target a specific window and app.
+ * All webview tools extend this to support multi-window and multi-app scenarios.
  */
 export const WindowTargetSchema = z.object({
     windowId: z.string().optional().describe('Window label to target (defaults to "main")'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID to target. Defaults to the only connected app or the default app if multiple are connected.'),
 });
 // ============================================================================
 // Schemas
@@ -76,17 +77,17 @@ export const GetConsoleLogsSchema = WindowTargetSchema.extend({
 // Implementation Functions
 // ============================================================================
 export async function interact(options) {
-    const { action, selector, x, y, duration, scrollX, scrollY, fromX, fromY, toX, toY, windowId } = options;
+    const { action, selector, x, y, duration, scrollX, scrollY, fromX, fromY, toX, toY, windowId, appIdentifier } = options;
     // Handle swipe action separately since it has different logic
     if (action === 'swipe') {
-        return performSwipe({ fromX, fromY, toX, toY, duration, windowId });
+        return performSwipe({ fromX, fromY, toX, toY, duration, windowId, appIdentifier });
     }
     // Handle focus action
     if (action === 'focus') {
         if (!selector) {
             throw new Error('Focus action requires a selector');
         }
-        return focusElement({ selector, windowId });
+        return focusElement({ selector, windowId, appIdentifier });
     }
     const script = buildScript(SCRIPTS.interact, {
         action,
@@ -98,7 +99,7 @@ export async function interact(options) {
         scrollY: scrollY ?? 0,
     });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -106,13 +107,13 @@ export async function interact(options) {
     }
 }
 async function performSwipe(options) {
-    const { fromX, fromY, toX, toY, duration = 300, windowId } = options;
+    const { fromX, fromY, toX, toY, duration = 300, windowId, appIdentifier } = options;
     if (fromX === undefined || fromY === undefined || toX === undefined || toY === undefined) {
         throw new Error('Swipe action requires fromX, fromY, toX, and toY coordinates');
     }
     const script = buildScript(SCRIPTS.swipe, { fromX, fromY, toX, toY, duration });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -120,9 +121,9 @@ async function performSwipe(options) {
     }
 }
 export async function screenshot(options = {}) {
-    const { quality, format = 'png', windowId, filePath } = options;
+    const { quality, format = 'png', windowId, filePath, appIdentifier } = options;
     // Use the native screenshot function from webview-executor
-    const result = await captureScreenshot({ format, quality, windowId });
+    const result = await captureScreenshot({ format, quality, windowId, appIdentifier });
     // If filePath is provided, write to file instead of returning base64
     if (filePath) {
         // Find the image content in the result
@@ -139,7 +140,7 @@ export async function screenshot(options = {}) {
     return result;
 }
 export async function keyboard(options) {
-    const { action, selectorOrKey, textOrModifiers, modifiers, windowId } = options;
+    const { action, selectorOrKey, textOrModifiers, modifiers, windowId, appIdentifier } = options;
     // Handle the different parameter combinations based on action
     if (action === 'type') {
         const selector = selectorOrKey;
@@ -149,7 +150,7 @@ export async function keyboard(options) {
         }
         const script = buildTypeScript(selector, text);
         try {
-            return await executeInWebview(script, windowId);
+            return await executeInWebview(script, windowId, appIdentifier);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -164,7 +165,7 @@ export async function keyboard(options) {
     }
     const script = buildKeyEventScript(action, key, mods || []);
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -172,10 +173,10 @@ export async function keyboard(options) {
     }
 }
 export async function waitFor(options) {
-    const { type, value, timeout = 5000, windowId } = options;
+    const { type, value, timeout = 5000, windowId, appIdentifier } = options;
     const script = buildScript(SCRIPTS.waitFor, { type, value, timeout });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -183,14 +184,14 @@ export async function waitFor(options) {
     }
 }
 export async function getStyles(options) {
-    const { selector, properties, multiple = false, windowId } = options;
+    const { selector, properties, multiple = false, windowId, appIdentifier } = options;
     const script = buildScript(SCRIPTS.getStyles, {
         selector,
         properties: properties || [],
         multiple,
     });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -198,7 +199,7 @@ export async function getStyles(options) {
     }
 }
 export async function executeJavaScript(options) {
-    const { script, args, windowId } = options;
+    const { script, args, windowId, appIdentifier } = options;
     // If args are provided, we need to inject them into the script context
     const wrappedScript = args && args.length > 0
         ? `
@@ -209,7 +210,7 @@ export async function executeJavaScript(options) {
       `
         : script;
     try {
-        const { result, windowLabel, warning } = await executeInWebviewWithContext(wrappedScript, windowId);
+        const { result, windowLabel, warning } = await executeInWebviewWithContext(wrappedScript, windowId, appIdentifier);
         // Build response with window context
         let response = result;
         if (warning) {
@@ -225,10 +226,10 @@ export async function executeJavaScript(options) {
     }
 }
 export async function focusElement(options) {
-    const { selector, windowId } = options;
+    const { selector, windowId, appIdentifier } = options;
     const script = buildScript(SCRIPTS.focus, { selector });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -239,10 +240,10 @@ export async function focusElement(options) {
  * Find an element using various selector strategies.
  */
 export async function findElement(options) {
-    const { selector, strategy, windowId } = options;
+    const { selector, strategy, windowId, appIdentifier } = options;
     const script = buildScript(SCRIPTS.findElement, { selector, strategy });
     try {
-        return await executeInWebview(script, windowId);
+        return await executeInWebview(script, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -253,9 +254,9 @@ export async function findElement(options) {
  * Get console logs from the webview.
  */
 export async function getConsoleLogs(options = {}) {
-    const { filter, since } = options;
+    const { filter, since, windowId, appIdentifier } = options;
     try {
-        return await getConsoleLogsFromCapture(filter, since);
+        return await getConsoleLogsFromCapture(filter, since, windowId, appIdentifier);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/monitor/logs.js

@@ -8,14 +8,15 @@ export const ReadLogsSchema = z.object({
     filter: z.string().optional().describe('Regex or keyword to filter logs'),
     since: z.string().optional().describe('ISO timestamp to filter logs since (e.g. 2023-10-27T10:00:00Z)'),
     windowId: z.string().optional().describe('Window label for console logs (defaults to "main")'),
+    appIdentifier: z.union([z.string(), z.number()]).optional().describe('App port or bundle ID for console logs. Defaults to the only connected app or the default app if multiple are connected.'),
 });
 export async function readLogs(options) {
-    const { source, lines = 50, filter, since, windowId } = options;
+    const { source, lines = 50, filter, since, windowId, appIdentifier } = options;
     try {
         let output = '';
         // Handle console logs (webview JS logs)
         if (source === 'console') {
-            return await getConsoleLogs({ filter, since, windowId });
+            return await getConsoleLogs({ filter, since, windowId, appIdentifier });
         }
         if (source === 'android') {
             // Find adb - check ANDROID_HOME first, then fall back to PATH

package/dist/tools-registry.js

@@ -8,6 +8,11 @@ import { manageDriverSession, ManageDriverSessionSchema, } from './driver/sessio
 import { readLogs, ReadLogsSchema } from './monitor/logs.js';
 import { executeIPCCommand, manageIPCMonitoring, getIPCEvents, emitTestEvent, getBackendState, manageWindow, ExecuteIPCCommandSchema, ManageIPCMonitoringSchema, GetIPCEventsSchema, EmitTestEventSchema, GetBackendStateSchema, ManageWindowSchema, } from './driver/plugin-commands.js';
 import { interact, screenshot, keyboard, waitFor, getStyles, executeJavaScript, findElement, InteractSchema, ScreenshotSchema, KeyboardSchema, WaitForSchema, GetStylesSchema, ExecuteJavaScriptSchema, FindElementSchema, } from './driver/webview-interactions.js';
+/**
+ * Standard multi-app description for webview tools.
+ */
+const MULTI_APP_DESC = 'Targets the only connected app, or the default app if multiple are connected. ' +
+    'Specify appIdentifier (port or bundle ID) to target a specific app.';
 /**
  * Tool categories for organization
  */
@@ -136,11 +141,12 @@ export const TOOLS = [
     {
         name: 'tauri_driver_session',
         description: '[Tauri Apps Only] Start/stop automation session to connect to a RUNNING Tauri app. ' +
-            'Use action "status" to check current connection state and get the app identifier. ' +
-            'The status response includes an "identifier" field (e.g., "com.example.myapp") that uniquely identifies the connected app. ' +
-            'The identifier may be null if the Tauri app uses an older plugin version that does not provide it. ' +
-            'Before starting a new session, check status first - if already connected to the correct app (matching identifier), ' +
-            'reuse the existing session. If identifier is null, you cannot verify the app identity. ' +
+            'Supports multiple concurrent app connections - each app runs on a unique port. ' +
+            'The most recently connected app becomes the "default" app used when no appIdentifier is specified. ' +
+            'Use action "status" to check connection state: returns single app format when 1 app connected, ' +
+            'or array format with "isDefault" indicator when multiple apps connected. ' +
+            'Action "stop" without appIdentifier stops ALL sessions; with appIdentifier stops only that app. ' +
+            'The identifier field (e.g., "com.example.myapp") uniquely identifies each app. ' +
             'REQUIRED before using other tauri_webview_* or tauri_plugin_* tools. ' +
             'Connects via WebSocket to the MCP Bridge plugin in the Tauri app. ' +
             'For browser automation, use Chrome DevTools MCP instead. ' +
@@ -156,13 +162,14 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = ManageDriverSessionSchema.parse(args);
-            return await manageDriverSession(parsed.action, parsed.host, parsed.port);
+            return await manageDriverSession(parsed.action, parsed.host, parsed.port, parsed.appIdentifier);
         },
     },
     {
         name: 'tauri_webview_find_element',
         description: '[Tauri Apps Only] Find DOM elements in a running Tauri app\'s webview. ' +
             'Requires active tauri_driver_session. ' +
+            MULTI_APP_DESC + ' ' +
             'For browser pages or documentation sites, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: FindElementSchema,
@@ -177,6 +184,7 @@ export const TOOLS = [
                 selector: parsed.selector,
                 strategy: parsed.strategy,
                 windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
             });
         },
     },
@@ -222,6 +230,7 @@ export const TOOLS = [
         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,
@@ -238,6 +247,7 @@ export const TOOLS = [
                 format: parsed.format,
                 windowId: parsed.windowId,
                 filePath: parsed.filePath,
+                appIdentifier: parsed.appIdentifier,
             });
             // If saved to file, return text confirmation
             if ('filePath' in result) {
@@ -251,6 +261,7 @@ export const TOOLS = [
         name: 'tauri_webview_keyboard',
         description: '[Tauri Apps Only] Type text or send keyboard events in a Tauri app. ' +
             'Requires active tauri_driver_session. ' +
+            MULTI_APP_DESC + ' ' +
             'For browser keyboard input, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: KeyboardSchema,
@@ -268,6 +279,7 @@ export const TOOLS = [
                     selectorOrKey: parsed.selector,
                     textOrModifiers: parsed.text,
                     windowId: parsed.windowId,
+                    appIdentifier: parsed.appIdentifier,
                 });
             }
             return await keyboard({
@@ -275,6 +287,7 @@ export const TOOLS = [
                 selectorOrKey: parsed.key,
                 textOrModifiers: parsed.modifiers,
                 windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
             });
         },
     },
@@ -282,6 +295,7 @@ export const TOOLS = [
         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,
@@ -297,6 +311,7 @@ export const TOOLS = [
                 value: parsed.value,
                 timeout: parsed.timeout,
                 windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
             });
         },
     },
@@ -304,6 +319,7 @@ export const TOOLS = [
         name: 'tauri_webview_get_styles',
         description: '[Tauri Apps Only] Get computed CSS styles from elements in a Tauri app. ' +
             'Requires active tauri_driver_session. ' +
+            MULTI_APP_DESC + ' ' +
             'For browser style inspection, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: GetStylesSchema,
@@ -319,6 +335,7 @@ export const TOOLS = [
                 properties: parsed.properties,
                 multiple: parsed.multiple,
                 windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
             });
         },
     },
@@ -328,6 +345,7 @@ export const TOOLS = [
             'Requires active tauri_driver_session. Has access to window.__TAURI__. ' +
             'If you need a return value, it must be JSON-serializable. ' +
             'For functions that return values, use an IIFE: "(() => { return 5; })()" not "() => { return 5; }". ' +
+            MULTI_APP_DESC + ' ' +
             'For browser JS execution, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ExecuteJavaScriptSchema,
@@ -343,6 +361,7 @@ export const TOOLS = [
                 script: parsed.script,
                 args: parsed.args,
                 windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
             });
         },
     },
@@ -362,7 +381,11 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = ExecuteIPCCommandSchema.parse(args);
-            return await executeIPCCommand(parsed.command, parsed.args);
+            return await executeIPCCommand({
+                command: parsed.command,
+                args: parsed.args,
+                appIdentifier: parsed.appIdentifier,
+            });
         },
     },
     {
@@ -381,7 +404,7 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = ManageIPCMonitoringSchema.parse(args);
-            return await manageIPCMonitoring(parsed.action);
+            return await manageIPCMonitoring(parsed.action, parsed.appIdentifier);
         },
     },
     {
@@ -398,7 +421,7 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = GetIPCEventsSchema.parse(args);
-            return await getIPCEvents(parsed.filter);
+            return await getIPCEvents(parsed.filter, parsed.appIdentifier);
         },
     },
     {
@@ -416,7 +439,7 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = EmitTestEventSchema.parse(args);
-            return await emitTestEvent(parsed.eventName, parsed.payload);
+            return await emitTestEvent(parsed.eventName, parsed.payload, parsed.appIdentifier);
         },
     },
     {
@@ -431,8 +454,9 @@ export const TOOLS = [
             readOnlyHint: true,
             openWorldHint: false,
         },
-        handler: async () => {
-            return await getBackendState();
+        handler: async (args) => {
+            const parsed = GetBackendStateSchema.parse(args);
+            return await getBackendState({ appIdentifier: parsed.appIdentifier });
         },
     },
     // Window Management Tools

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@hypothesi/tauri-mcp-server",
-  "version": "0.5.1",
-  "description": "A Model Context Protocol server for Tauri v2 development",
+  "version": "0.6.2",
+  "mcpName": "io.github.hypothesi/tauri",
+  "description": "A Model Context Protocol server for use with Tauri v2 applications",
   "type": "module",
   "bin": {
     "mcp-server-tauri": "./dist/index.js"