@hypothesi/tauri-mcp-server 0.2.1 → 0.3.0

package/dist/tools-registry.js

@@ -2,19 +2,15 @@
  * Single source of truth for all MCP tool definitions
  * This file defines all available tools and their metadata
  */
-import { runTauriCommand, RunCommandSchema } from './manager/cli.js';
-import { readConfig, writeConfig, ReadConfigSchema, WriteConfigSchema } from './manager/config.js';
-import { listDevices, launchEmulator, ListDevicesSchema, LaunchEmulatorSchema } from './manager/mobile.js';
+import { listDevices, ListDevicesSchema } from './manager/mobile.js';
 import { manageDriverSession, ManageDriverSessionSchema, } from './driver/session-manager.js';
 import { readLogs, ReadLogsSchema } from './monitor/logs.js';
-import { getDocs, GetDocsSchema } from './manager/docs.js';
-import { executeIPCCommand, getWindowInfo, manageIPCMonitoring, getIPCEvents, emitTestEvent, getBackendState, listWindows, ExecuteIPCCommandSchema, GetWindowInfoSchema, ManageIPCMonitoringSchema, GetIPCEventsSchema, EmitTestEventSchema, GetBackendStateSchema, ListWindowsSchema, } from './driver/plugin-commands.js';
-import { interact, screenshot, keyboard, waitFor, getStyles, executeJavaScript, focusElement, findElement, getConsoleLogs, InteractSchema, ScreenshotSchema, KeyboardSchema, WaitForSchema, GetStylesSchema, ExecuteJavaScriptSchema, FocusElementSchema, FindElementSchema, GetConsoleLogsSchema, } from './driver/webview-interactions.js';
+import { executeIPCCommand, manageIPCMonitoring, getIPCEvents, emitTestEvent, getBackendState, listWindows, ExecuteIPCCommandSchema, ManageIPCMonitoringSchema, GetIPCEventsSchema, EmitTestEventSchema, GetBackendStateSchema, ListWindowsSchema, } 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';
 /**
  * Tool categories for organization
  */
 export const TOOL_CATEGORIES = {
-    PROJECT_MANAGEMENT: 'Project Management',
     MOBILE_DEVELOPMENT: 'Mobile Development',
     UI_AUTOMATION: 'UI Automation & WebView Interaction',
     IPC_PLUGIN: 'IPC & Plugin Tools (via MCP Bridge)',
@@ -24,79 +20,6 @@ export const TOOL_CATEGORIES = {
  * This is the single source of truth for tool definitions
  */
 export const TOOLS = [
-    // Project Management Tools
-    {
-        name: 'tauri_run_command',
-        description: '[Tauri Desktop/Mobile Apps Only] Run Tauri CLI commands (dev, build, init, etc.). ' +
-            'Use ONLY for projects with a src-tauri/ directory and tauri.conf.json. ' +
-            'Do NOT use for regular web apps, Electron apps, or browser-based projects. ' +
-            'Check for tauri.conf.json before using this tool.',
-        category: TOOL_CATEGORIES.PROJECT_MANAGEMENT,
-        schema: RunCommandSchema,
-        annotations: {
-            title: 'Run Tauri CLI Command',
-            readOnlyHint: false,
-            destructiveHint: false,
-            idempotentHint: false,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = RunCommandSchema.parse(args);
-            return await runTauriCommand(parsed.command, parsed.cwd, parsed.args || [], parsed.timeout);
-        },
-    },
-    {
-        name: 'tauri_read_config',
-        description: '[Tauri Desktop/Mobile Apps Only] Read tauri.conf.json or platform-specific configs. ' +
-            'Use ONLY for Tauri v2 projects (look for src-tauri/ directory). ' +
-            'For regular web apps or Electron, use standard file reading tools instead.',
-        category: TOOL_CATEGORIES.PROJECT_MANAGEMENT,
-        schema: ReadConfigSchema,
-        annotations: {
-            title: 'Read Tauri Config',
-            readOnlyHint: true,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = ReadConfigSchema.parse(args);
-            return await readConfig(parsed.projectPath, parsed.file);
-        },
-    },
-    {
-        name: 'tauri_write_config',
-        description: '[Tauri Desktop/Mobile Apps Only] Modify tauri.conf.json with validation. ' +
-            'Use ONLY for Tauri v2 projects. Validates JSON structure before writing. ' +
-            'For other frameworks, use standard file editing tools.',
-        category: TOOL_CATEGORIES.PROJECT_MANAGEMENT,
-        schema: WriteConfigSchema,
-        annotations: {
-            title: 'Write Tauri Config',
-            readOnlyHint: false,
-            destructiveHint: true,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = WriteConfigSchema.parse(args);
-            return await writeConfig(parsed.projectPath, parsed.file, parsed.content);
-        },
-    },
-    {
-        name: 'tauri_get_docs',
-        description: '[Tauri Desktop/Mobile Apps Only] Fetch Tauri v2 documentation and API reference. ' +
-            'Use when working on Tauri projects and need framework-specific guidance. ' +
-            'Not useful for Electron, React Native, or web-only projects.',
-        category: TOOL_CATEGORIES.PROJECT_MANAGEMENT,
-        schema: GetDocsSchema,
-        annotations: {
-            title: 'Get Tauri Documentation',
-            readOnlyHint: true,
-            openWorldHint: true,
-        },
-        handler: async (args) => {
-            const parsed = GetDocsSchema.parse(args);
-            return await getDocs(parsed.projectPath);
-        },
-    },
     // Mobile Development Tools
     {
         name: 'tauri_list_devices',
@@ -115,28 +38,11 @@ export const TOOLS = [
             return `Android Devices:\n${devices.android.join('\n') || 'None'}\n\niOS Booted Simulators:\n${devices.ios.join('\n') || 'None'}`;
         },
     },
-    {
-        name: 'tauri_launch_emulator',
-        description: '[Tauri Mobile Apps Only] Launch Android AVD or iOS Simulator for Tauri mobile testing. ' +
-            'Use when developing Tauri apps for mobile platforms. ' +
-            'Not applicable for desktop-only apps or web projects.',
-        category: TOOL_CATEGORIES.MOBILE_DEVELOPMENT,
-        schema: LaunchEmulatorSchema,
-        annotations: {
-            title: 'Launch Mobile Emulator',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = LaunchEmulatorSchema.parse(args);
-            return await launchEmulator(parsed.platform, parsed.name);
-        },
-    },
     // UI Automation 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. ' +
             '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. ' +
@@ -177,47 +83,28 @@ export const TOOLS = [
         },
     },
     {
-        name: 'tauri_driver_get_console_logs',
-        description: '[Tauri Apps Only] Get JavaScript console logs from a running Tauri app. ' +
-            'Requires active tauri_driver_session. Use for debugging Tauri webview issues. ' +
-            'For browser console logs, use Chrome DevTools MCP instead.',
-        category: TOOL_CATEGORIES.UI_AUTOMATION,
-        schema: GetConsoleLogsSchema,
-        annotations: {
-            title: 'Get Tauri Console Logs',
-            readOnlyHint: true,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = GetConsoleLogsSchema.parse(args);
-            return await getConsoleLogs({
-                filter: parsed.filter,
-                since: parsed.since,
-                windowId: parsed.windowId,
-            });
-        },
-    },
-    {
-        name: 'tauri_read_platform_logs',
-        description: '[Tauri Mobile Apps] Read Android logcat or iOS device logs for Tauri mobile apps. ' +
-            'Also reads system logs on desktop. ' +
-            'Use for debugging native/platform-level issues in Tauri apps.',
+        name: 'tauri_read_logs',
+        description: '[Tauri Apps Only] Read logs from various sources: "console" for webview JS logs, ' +
+            '"android" for logcat, "ios" for simulator logs, "system" for desktop logs. ' +
+            'Requires active tauri_driver_session for console logs. ' +
+            'Use for debugging Tauri app issues at any level.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ReadLogsSchema,
         annotations: {
-            title: 'Read Platform Logs',
+            title: 'Read Logs',
             readOnlyHint: true,
             openWorldHint: false,
         },
         handler: async (args) => {
             const parsed = ReadLogsSchema.parse(args);
-            return await readLogs(parsed.source, parsed.lines, parsed.filter, parsed.since);
+            return await readLogs(parsed);
         },
     },
     // WebView Interaction Tools
     {
         name: 'tauri_webview_interact',
-        description: '[Tauri Apps Only] Click, scroll, swipe, or perform gestures in a Tauri app webview. ' +
+        description: '[Tauri Apps Only] Click, scroll, swipe, focus, or perform gestures in a Tauri app webview. ' +
+            'Supported actions: click, double-click, long-press, scroll, swipe, focus. ' +
             'Requires active tauri_driver_session. ' +
             'For browser interaction, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
@@ -248,11 +135,18 @@ export const TOOLS = [
         },
         handler: async (args) => {
             const parsed = ScreenshotSchema.parse(args);
-            return await screenshot({
+            const result = await screenshot({
                 quality: parsed.quality,
                 format: parsed.format,
                 windowId: parsed.windowId,
+                filePath: parsed.filePath,
             });
+            // If saved to file, return text confirmation
+            if ('filePath' in result) {
+                return `Screenshot saved to: ${result.filePath}`;
+            }
+            // Return the content array directly for proper image handling
+            return result.content;
         },
     },
     {
@@ -352,27 +246,9 @@ export const TOOLS = [
             });
         },
     },
-    {
-        name: 'tauri_webview_focus_element',
-        description: '[Tauri Apps Only] Focus a DOM element in a Tauri app\'s webview. ' +
-            'Requires active tauri_driver_session. ' +
-            'For browser focus, use Chrome DevTools MCP instead.',
-        category: TOOL_CATEGORIES.UI_AUTOMATION,
-        schema: FocusElementSchema,
-        annotations: {
-            title: 'Focus Element in Tauri',
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: false,
-        },
-        handler: async (args) => {
-            const parsed = FocusElementSchema.parse(args);
-            return await focusElement({ selector: parsed.selector, windowId: parsed.windowId });
-        },
-    },
     // IPC & Plugin Tools
     {
-        name: 'tauri_plugin_execute_ipc',
+        name: 'tauri_ipc_execute_command',
         description: '[Tauri Apps Only] Execute Tauri IPC commands (invoke Rust backend functions). ' +
             'Requires active tauri_driver_session. This is Tauri-specific IPC, not browser APIs. ' +
             'For Electron IPC or browser APIs, use appropriate tools for those frameworks.',
@@ -390,23 +266,7 @@ export const TOOLS = [
         },
     },
     {
-        name: 'tauri_plugin_get_window_info',
-        description: '[Tauri Apps Only] Get Tauri window information (size, position, state). ' +
-            'Requires active tauri_driver_session. ' +
-            'For browser window info, use Chrome DevTools MCP instead.',
-        category: TOOL_CATEGORIES.IPC_PLUGIN,
-        schema: GetWindowInfoSchema,
-        annotations: {
-            title: 'Get Tauri Window Info',
-            readOnlyHint: true,
-            openWorldHint: false,
-        },
-        handler: async () => {
-            return await getWindowInfo();
-        },
-    },
-    {
-        name: 'tauri_plugin_ipc_monitor',
+        name: 'tauri_ipc_monitor',
         description: '[Tauri Apps Only] Monitor Tauri IPC calls between frontend and Rust backend. ' +
             'Requires active tauri_driver_session. Captures invoke() calls and responses. ' +
             'This is Tauri-specific; for browser network monitoring, use Chrome DevTools MCP.',
@@ -425,14 +285,14 @@ export const TOOLS = [
         },
     },
     {
-        name: 'tauri_plugin_ipc_get_events',
-        description: '[Tauri Apps Only] Get captured Tauri IPC events (requires ipc_monitor started). ' +
-            'Shows Tauri command invocations with arguments and responses. ' +
+        name: 'tauri_ipc_get_captured',
+        description: '[Tauri Apps Only] Get captured Tauri IPC traffic (requires ipc_monitor started). ' +
+            'Shows captured commands (invoke calls) and events with arguments and responses. ' +
             'For browser network requests, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.IPC_PLUGIN,
         schema: GetIPCEventsSchema,
         annotations: {
-            title: 'Get Tauri IPC Events',
+            title: 'Get Captured IPC Traffic',
             readOnlyHint: true,
             openWorldHint: false,
         },
@@ -442,7 +302,7 @@ export const TOOLS = [
         },
     },
     {
-        name: 'tauri_plugin_emit_event',
+        name: 'tauri_ipc_emit_event',
         description: '[Tauri Apps Only] Emit a Tauri event to test event handlers. ' +
             'Requires active tauri_driver_session. Events are Tauri-specific (not DOM events). ' +
             'For browser DOM events, use Chrome DevTools MCP instead.',
@@ -460,7 +320,7 @@ export const TOOLS = [
         },
     },
     {
-        name: 'tauri_plugin_get_backend_state',
+        name: 'tauri_ipc_get_backend_state',
         description: '[Tauri Apps Only] Get Tauri backend state: app metadata, Tauri version, environment. ' +
             'Requires active tauri_driver_session. ' +
             'Use to verify you\'re connected to a Tauri app and get app info.',
@@ -478,7 +338,8 @@ export const TOOLS = [
     // Window Management Tools
     {
         name: 'tauri_list_windows',
-        description: '[Tauri Apps Only] List all Tauri webview windows (labels, titles, URLs, state). ' +
+        description: '[Tauri Apps Only] List all Tauri webview windows with details including ' +
+            'labels, titles, URLs, and state (focused, visible, isMain). ' +
             'Requires active tauri_driver_session. Use to discover windows before targeting them. ' +
             'For browser tabs/windows, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypothesi/tauri-mcp-server",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "A Model Context Protocol server for Tauri v2 development",
   "type": "module",
   "bin": {

package/dist/manager/cli.js

@@ -1,128 +0,0 @@
-import { z } from 'zod';
-import { execa } from 'execa';
-import fs from 'fs/promises';
-import path from 'path';
-export const RunCommandSchema = z.object({
-    command: z.string().describe('Any Tauri CLI command (e.g., "init", "dev", "build", "android dev", "migrate", "plugin add", etc.)'),
-    args: z.array(z.string()).optional().describe('Additional arguments to pass to the command'),
-    cwd: z.string().describe('The project directory'),
-    timeout: z.number().optional().describe('Command timeout in milliseconds (default: 180000)'),
-});
-/**
- * Get available Tauri commands by running 'tauri --help'
- */
-export async function listTauriCommands(cwd) {
-    try {
-        const packageJsonPath = path.join(cwd, 'package.json');
-        const hasTauriScript = await fs
-            .readFile(packageJsonPath, 'utf8')
-            .then((content) => {
-            try {
-                const pkg = JSON.parse(content);
-                return Boolean(pkg.scripts && pkg.scripts.tauri);
-            }
-            catch {
-                return false;
-            }
-        })
-            .catch(() => { return false; });
-        let result;
-        if (hasTauriScript) {
-            result = await execa('npm', ['run', 'tauri', '--', '--help'], {
-                cwd,
-                timeout: 10000,
-            });
-        }
-        else {
-            result = await execa('tauri', ['--help'], {
-                cwd,
-                timeout: 10000,
-            });
-        }
-        return result.stdout;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to get Tauri commands: ${message}`);
-    }
-}
-export async function runTauriCommand(command, cwd, args = [], timeout = 180000) {
-    try {
-        // Split command if it contains spaces (e.g., "android dev" or "plugin add")
-        const commandParts = command.split(' ');
-        const allArgs = [...commandParts, ...args];
-        const packageJsonPath = path.join(cwd, 'package.json');
-        const hasTauriScript = await fs
-            .readFile(packageJsonPath, 'utf8')
-            .then((content) => {
-            try {
-                const pkg = JSON.parse(content);
-                return Boolean(pkg.scripts && pkg.scripts.tauri);
-            }
-            catch {
-                return false;
-            }
-        })
-            .catch(() => { return false; });
-        const isDevLikeCommand = commandParts[0] === 'dev' ||
-            command.startsWith('android dev') ||
-            command.startsWith('ios dev');
-        const spawnTauri = () => {
-            if (hasTauriScript) {
-                return execa('npm', ['run', 'tauri', '--', ...allArgs], {
-                    cwd,
-                    timeout: isDevLikeCommand ? undefined : timeout,
-                });
-            }
-            return execa('tauri', allArgs, {
-                cwd,
-                timeout: isDevLikeCommand ? undefined : timeout,
-            });
-        };
-        const child = spawnTauri();
-        if (isDevLikeCommand) {
-            // For long-running dev commands, start the process and return once the
-            // command appears healthy
-            child.catch(() => { return; });
-            await new Promise((resolve) => {
-                setTimeout(resolve, 3000);
-            });
-            if (child.exitCode !== null) {
-                if (child.exitCode === 0) {
-                    return 'Tauri dev command completed successfully.';
-                }
-                throw new Error('Tauri dev command exited unexpectedly. Check your project configuration and logs for details.');
-            }
-            const text = [
-                'Tauri dev command started. It may still be initializing; check your terminal',
-                'or devtools logs for live output. Use Ctrl+C in the appropriate terminal to',
-                'stop it.',
-            ];
-            return text.join(' ');
-        }
-        const result = await child;
-        if (Array.isArray(result.stdout)) {
-            return result.stdout.join('\n');
-        }
-        if (result.stdout instanceof Uint8Array) {
-            return new TextDecoder().decode(result.stdout);
-        }
-        return result.stdout || 'Command completed successfully';
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error), stderr = error && typeof error === 'object' && 'stderr' in error ? String(error.stderr) : '';
-        // Provide more helpful error messages
-        if (message.includes('Unknown command')) {
-            throw new Error(`Unknown Tauri command: "${command}". Run 'tauri --help' to see available commands.\n${stderr}`);
-        }
-        if (message.includes('spawn tauri ENOENT')) {
-            const msgParts = [
-                'Failed to run the Tauri CLI. Either add a "tauri" script to your',
-                'package.json (e.g., "tauri": "tauri") or install the global Tauri CLI',
-                'as described in the documentation, then try again.',
-            ];
-            throw new Error(msgParts.join(' '));
-        }
-        throw new Error(`Tauri command failed: ${message}${stderr ? `\n${stderr}` : ''}`);
-    }
-}

package/dist/manager/config.js

@@ -1,142 +0,0 @@
-import { z } from 'zod';
-import fs from 'fs/promises';
-import path from 'path';
-// Tauri supports multiple configuration files
-const TAURI_CONFIG_FILES = [
-    'tauri.conf.json',
-    'tauri.conf.json5',
-    'Tauri.toml',
-    // Platform-specific configs
-    'tauri.windows.conf.json',
-    'tauri.linux.conf.json',
-    'tauri.macos.conf.json',
-    'tauri.android.conf.json',
-    'tauri.ios.conf.json',
-    // Build-specific configs
-    'tauri.conf.dev.json',
-    'tauri.conf.prod.json',
-    // Project files
-    'Cargo.toml',
-    'package.json',
-    // Mobile-specific files
-    'Info.plist',
-    'AndroidManifest.xml',
-];
-export const ReadConfigSchema = z.object({
-    projectPath: z.string(),
-    file: z.enum(TAURI_CONFIG_FILES).describe('Tauri configuration file to read'),
-});
-export const WriteConfigSchema = z.object({
-    projectPath: z.string(),
-    file: z.enum(TAURI_CONFIG_FILES).describe('Tauri configuration file to write'),
-    content: z.string().describe('The new content of the file'),
-});
-export async function readConfig(projectPath, file) {
-    const filePath = path.join(projectPath, getRelativePath(file));
-    try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        return content;
-    }
-    catch (error) {
-        throw new Error(`Failed to read ${file}: ${error}`);
-    }
-}
-/**
- * List all available Tauri configuration files in the project
- */
-export async function listConfigFiles(projectPath) {
-    const availableFiles = [];
-    for (const file of TAURI_CONFIG_FILES) {
-        const filePath = path.join(projectPath, getRelativePath(file));
-        try {
-            await fs.access(filePath);
-            availableFiles.push(file);
-        }
-        catch (e) {
-            // File doesn't exist, skip it
-        }
-    }
-    return availableFiles;
-}
-export async function writeConfig(projectPath, file, content) {
-    const filePath = path.join(projectPath, getRelativePath(file));
-    // Validate JSON files
-    if (file.endsWith('.json')) {
-        try {
-            JSON.parse(content);
-        }
-        catch (e) {
-            throw new Error(`Invalid JSON content for ${file}`);
-        }
-    }
-    // Validate JSON5 files
-    if (file.endsWith('.json5')) {
-        // JSON5 is a superset of JSON, basic validation
-        // In production, you'd want to use a json5 parser
-        try {
-            // At minimum, check for basic syntax
-            if (!content.trim()) {
-                throw new Error(`Empty content for ${file}`);
-            }
-        }
-        catch (e) {
-            throw new Error(`Invalid content for ${file}`);
-        }
-    }
-    // Validate TOML files
-    if (file.endsWith('.toml')) {
-        // Basic TOML validation - in production use a TOML parser
-        if (!content.trim()) {
-            throw new Error(`Empty content for ${file}`);
-        }
-    }
-    // Validate XML files
-    if (file.endsWith('.xml')) {
-        // Basic XML validation
-        if (!content.includes('<') || !content.includes('>')) {
-            throw new Error(`Invalid XML content for ${file}`);
-        }
-    }
-    // Validate plist files
-    if (file.endsWith('.plist')) {
-        // plist files are XML-based
-        if (!content.includes('<?xml') || !content.includes('<plist')) {
-            throw new Error(`Invalid plist content for ${file}`);
-        }
-    }
-    try {
-        await fs.writeFile(filePath, content, 'utf-8');
-        return `Successfully wrote to ${file}`;
-    }
-    catch (error) {
-        throw new Error(`Failed to write ${file}: ${error}`);
-    }
-}
-function getRelativePath(file) {
-    // Main Tauri config files
-    if (file === 'tauri.conf.json' || file === 'tauri.conf.json5' || file === 'Tauri.toml') {
-        return `src-tauri/${file}`;
-    }
-    // Platform-specific Tauri configs
-    if (file.startsWith('tauri.') && (file.endsWith('.conf.json') || file.endsWith('.conf.json5'))) {
-        return `src-tauri/${file}`;
-    }
-    // Cargo.toml
-    if (file === 'Cargo.toml') {
-        return 'src-tauri/Cargo.toml';
-    }
-    // iOS Info.plist
-    if (file === 'Info.plist') {
-        return 'src-tauri/gen/apple/Runner/Info.plist';
-    }
-    // Android manifest
-    if (file === 'AndroidManifest.xml') {
-        return 'src-tauri/gen/android/app/src/main/AndroidManifest.xml';
-    }
-    // Package.json is at root
-    if (file === 'package.json') {
-        return 'package.json';
-    }
-    // Default: assume it's relative to project root
-    return file;
-}