@hypothesi/tauri-mcp-server 0.1.2 → 0.2.0

package/dist/tools-registry.js

@@ -8,7 +8,7 @@ import { listDevices, launchEmulator, ListDevicesSchema, LaunchEmulatorSchema }
 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, ExecuteIPCCommandSchema, GetWindowInfoSchema, ManageIPCMonitoringSchema, GetIPCEventsSchema, EmitTestEventSchema, GetBackendStateSchema, } from './driver/plugin-commands.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';
 /**
  * Tool categories for organization
@@ -27,9 +27,19 @@ export const TOOLS = [
     // Project Management Tools
     {
         name: 'tauri_run_command',
-        description: 'Run any Tauri CLI command with full flexibility',
+        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);
@@ -37,9 +47,16 @@ export const TOOLS = [
     },
     {
         name: 'tauri_read_config',
-        description: 'Read Tauri configuration files (including platform-specific configs)',
+        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);
@@ -47,9 +64,17 @@ export const TOOLS = [
     },
     {
         name: 'tauri_write_config',
-        description: 'Write to Tauri configuration files with validation',
+        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);
@@ -57,9 +82,16 @@ export const TOOLS = [
     },
     {
         name: 'tauri_get_docs',
-        description: 'Get Tauri documentation (LLM Cheat Sheet)',
+        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);
@@ -68,9 +100,16 @@ export const TOOLS = [
     // Mobile Development Tools
     {
         name: 'tauri_list_devices',
-        description: 'List Android devices and iOS simulators',
+        description: '[Tauri Mobile Apps Only] List Android emulators/devices and iOS simulators. ' +
+            'Use for Tauri mobile development (tauri android dev, tauri ios dev). ' +
+            'Not needed for desktop-only Tauri apps or web projects.',
         category: TOOL_CATEGORIES.MOBILE_DEVELOPMENT,
         schema: ListDevicesSchema,
+        annotations: {
+            title: 'List Mobile Devices',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async () => {
             const devices = await listDevices();
             return `Android Devices:\n${devices.android.join('\n') || 'None'}\n\niOS Booted Simulators:\n${devices.ios.join('\n') || 'None'}`;
@@ -78,9 +117,17 @@ export const TOOLS = [
     },
     {
         name: 'tauri_launch_emulator',
-        description: 'Launch Android AVD or iOS Simulator',
+        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);
@@ -89,9 +136,20 @@ export const TOOLS = [
     // UI Automation Tools
     {
         name: 'tauri_driver_session',
-        description: 'Manage automation session (start or stop). Supports remote device connections via host parameter.',
+        description: '[Tauri Apps Only] Start/stop automation session to connect to a RUNNING Tauri 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. ' +
+            'For Electron apps, this tool will NOT work.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ManageDriverSessionSchema,
+        annotations: {
+            title: 'Manage Tauri Session',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ManageDriverSessionSchema.parse(args);
             return await manageDriverSession(parsed.action, parsed.host, parsed.port);
@@ -99,29 +157,58 @@ export const TOOLS = [
     },
     {
         name: 'tauri_webview_find_element',
-        description: 'Find elements',
+        description: '[Tauri Apps Only] Find DOM elements in a running Tauri app\'s webview. ' +
+            'Requires active tauri_driver_session. ' +
+            'For browser pages or documentation sites, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: FindElementSchema,
+        annotations: {
+            title: 'Find Element in Tauri Webview',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = FindElementSchema.parse(args);
-            return await findElement(parsed.selector, parsed.strategy);
+            return await findElement({
+                selector: parsed.selector,
+                strategy: parsed.strategy,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_driver_get_console_logs',
-        description: '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(parsed.filter, parsed.since);
+            return await getConsoleLogs({
+                filter: parsed.filter,
+                since: parsed.since,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_read_platform_logs',
-        description: 'Read platform logs (Android logcat, iOS device logs, or system 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.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ReadLogsSchema,
+        annotations: {
+            title: 'Read Platform Logs',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ReadLogsSchema.parse(args);
             return await readLogs(parsed.source, parsed.lines, parsed.filter, parsed.since);
@@ -130,9 +217,17 @@ export const TOOLS = [
     // WebView Interaction Tools
     {
         name: 'tauri_webview_interact',
-        description: 'Perform gestures (click, double-click, long-press, swipe) or scroll',
+        description: '[Tauri Apps Only] Click, scroll, swipe, or perform gestures in a Tauri app webview. ' +
+            'Requires active tauri_driver_session. ' +
+            'For browser interaction, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: InteractSchema,
+        annotations: {
+            title: 'Interact with Tauri Webview',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = InteractSchema.parse(args);
             return await interact(parsed);
@@ -140,75 +235,155 @@ export const TOOLS = [
     },
     {
         name: 'tauri_webview_screenshot',
-        description: 'Take a screenshot of the current viewport (visible area) of the webview. ' +
-            '**Important**: This only captures what is currently visible. ' +
-            'Scroll content into view before taking screenshots if you need to capture specific elements.',
+        description: '[Tauri Apps Only] Screenshot a running Tauri app\'s webview. ' +
+            'Requires active tauri_driver_session. Captures only visible viewport. ' +
+            'For browser screenshots, use Chrome DevTools MCP instead. ' +
+            'For Electron apps, this will NOT work.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ScreenshotSchema,
+        annotations: {
+            title: 'Screenshot Tauri Webview',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ScreenshotSchema.parse(args);
-            return await screenshot(parsed.quality, parsed.format);
+            return await screenshot({
+                quality: parsed.quality,
+                format: parsed.format,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_webview_keyboard',
-        description: 'Type text or simulate keyboard events',
+        description: '[Tauri Apps Only] Type text or send keyboard events in a Tauri app. ' +
+            'Requires active tauri_driver_session. ' +
+            'For browser keyboard input, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: KeyboardSchema,
+        annotations: {
+            title: 'Keyboard Input in Tauri',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = KeyboardSchema.parse(args);
             if (parsed.action === 'type') {
-                return await keyboard(parsed.action, parsed.selector, parsed.text);
+                return await keyboard({
+                    action: parsed.action,
+                    selectorOrKey: parsed.selector,
+                    textOrModifiers: parsed.text,
+                    windowId: parsed.windowId,
+                });
             }
-            return await keyboard(parsed.action, parsed.key, parsed.modifiers);
+            return await keyboard({
+                action: parsed.action,
+                selectorOrKey: parsed.key,
+                textOrModifiers: parsed.modifiers,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_webview_wait_for',
-        description: 'Wait for elements, text, or events',
+        description: '[Tauri Apps Only] Wait for elements, text, or IPC events in a Tauri app. ' +
+            'Requires active tauri_driver_session. ' +
+            '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(parsed.type, parsed.value, parsed.timeout);
+            return await waitFor({
+                type: parsed.type,
+                value: parsed.value,
+                timeout: parsed.timeout,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_webview_get_styles',
-        description: 'Get computed CSS styles',
+        description: '[Tauri Apps Only] Get computed CSS styles from elements in a Tauri app. ' +
+            'Requires active tauri_driver_session. ' +
+            'For browser style inspection, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: GetStylesSchema,
+        annotations: {
+            title: 'Get Styles in Tauri Webview',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = GetStylesSchema.parse(args);
-            return await getStyles(parsed.selector, parsed.properties, parsed.multiple);
+            return await getStyles({
+                selector: parsed.selector,
+                properties: parsed.properties,
+                multiple: parsed.multiple,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_webview_execute_js',
-        description: 'Execute JavaScript in webview',
+        description: '[Tauri Apps Only] Execute JavaScript in a Tauri app\'s webview context. ' +
+            'Requires active tauri_driver_session. Has access to window.__TAURI__. ' +
+            'For browser JS execution, use Chrome DevTools MCP instead.',
         category: TOOL_CATEGORIES.UI_AUTOMATION,
         schema: ExecuteJavaScriptSchema,
+        annotations: {
+            title: 'Execute JS in Tauri Webview',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ExecuteJavaScriptSchema.parse(args);
-            return await executeJavaScript(parsed.script, parsed.args);
+            return await executeJavaScript({
+                script: parsed.script,
+                args: parsed.args,
+                windowId: parsed.windowId,
+            });
         },
     },
     {
         name: 'tauri_webview_focus_element',
-        description: 'Focus on specific elements',
+        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(parsed.selector);
+            return await focusElement({ selector: parsed.selector, windowId: parsed.windowId });
         },
     },
     // IPC & Plugin Tools
     {
         name: 'tauri_plugin_execute_ipc',
-        description: 'Execute Tauri IPC commands',
+        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.',
         category: TOOL_CATEGORIES.IPC_PLUGIN,
         schema: ExecuteIPCCommandSchema,
+        annotations: {
+            title: 'Execute Tauri IPC Command',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ExecuteIPCCommandSchema.parse(args);
             return await executeIPCCommand(parsed.command, parsed.args);
@@ -216,19 +391,34 @@ export const TOOLS = [
     },
     {
         name: 'tauri_plugin_get_window_info',
-        description: 'Get window information',
+        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',
-        description: 'Start or stop IPC monitoring to capture Tauri command invocations. ' +
-            'Use "start" to begin capturing, then tauri_plugin_ipc_get_events to retrieve captured events.',
+        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.',
         category: TOOL_CATEGORIES.IPC_PLUGIN,
         schema: ManageIPCMonitoringSchema,
+        annotations: {
+            title: 'Monitor Tauri IPC',
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = ManageIPCMonitoringSchema.parse(args);
             return await manageIPCMonitoring(parsed.action);
@@ -236,11 +426,16 @@ export const TOOLS = [
     },
     {
         name: 'tauri_plugin_ipc_get_events',
-        description: 'Retrieve IPC events captured since monitoring started. ' +
-            'Shows Tauri command invocations with their arguments and responses. ' +
-            'Requires tauri_plugin_ipc_monitor to be started first.',
+        description: '[Tauri Apps Only] Get captured Tauri IPC events (requires ipc_monitor started). ' +
+            'Shows Tauri command invocations 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',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = GetIPCEventsSchema.parse(args);
             return await getIPCEvents(parsed.filter);
@@ -248,10 +443,17 @@ export const TOOLS = [
     },
     {
         name: 'tauri_plugin_emit_event',
-        description: 'Emit a custom Tauri event that can be listened to by the frontend or backend. ' +
-            'Useful for testing event handlers or triggering application behavior.',
+        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.',
         category: TOOL_CATEGORIES.IPC_PLUGIN,
         schema: EmitTestEventSchema,
+        annotations: {
+            title: 'Emit Tauri Event',
+            readOnlyHint: false,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
         handler: async (args) => {
             const parsed = EmitTestEventSchema.parse(args);
             return await emitTestEvent(parsed.eventName, parsed.payload);
@@ -259,13 +461,37 @@ export const TOOLS = [
     },
     {
         name: 'tauri_plugin_get_backend_state',
-        description: 'Get comprehensive backend state including app metadata, Tauri version, environment info, and window list',
+        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.',
         category: TOOL_CATEGORIES.IPC_PLUGIN,
         schema: GetBackendStateSchema,
+        annotations: {
+            title: 'Get Tauri Backend State',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
         handler: async () => {
             return await getBackendState();
         },
     },
+    // Window Management Tools
+    {
+        name: 'tauri_list_windows',
+        description: '[Tauri Apps Only] List all Tauri webview windows (labels, titles, URLs, state). ' +
+            '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,
+        schema: ListWindowsSchema,
+        annotations: {
+            title: 'List Tauri Windows',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async () => {
+            return await listWindows();
+        },
+    },
 ];
 /**
  * Get tools grouped by category

package/dist/types/window.js

@@ -0,0 +1,4 @@
+/**
+ * Window type definitions for multi-webview support.
+ */
+export {};

package/package.json

@@ -1,60 +1,60 @@
 {
-   "name": "@hypothesi/tauri-mcp-server",
-   "version": "0.1.2",
-   "description": "A Model Context Protocol server for Tauri v2 development",
-   "type": "module",
-   "bin": {
-      "mcp-server-tauri": "./dist/index.js"
-   },
-   "scripts": {
-      "build": "tsc && cp -r src/driver/scripts/*.js dist/driver/scripts/ && chmod +x dist/index.js",
-      "start": "node dist/index.js",
-      "test": "vitest run",
-      "test:unit": "vitest run --config vitest.config.unit.ts",
-      "test:e2e": "vitest run --config vitest.config.ts",
-      "dev": "tsc --watch",
-      "generate:docs": "tsx scripts/generate-tools-docs.ts",
-      "prepublishOnly": "npm run build"
-   },
-   "repository": {
-      "type": "git",
-      "url": "https://github.com/hypothesi/mcp-server-tauri.git",
-      "directory": "packages/mcp-server"
-   },
-   "files": [
-      "dist",
-      "package.json",
-      "README.md",
-      "LICENSE"
-   ],
-   "author": "hypothesi",
-   "license": "MIT",
-   "keywords": [
-      "mcp",
-      "model-context-protocol",
-      "tauri",
-      "automation",
-      "testing",
-      "debugging",
-      "cursor",
-      "windsurf",
-      "vscode"
-   ],
-   "dependencies": {
-      "@modelcontextprotocol/sdk": "0.6.1",
-      "execa": "9.6.0",
-      "html2canvas": "1.4.1",
-      "ws": "8.18.3",
-      "zod": "3.25.76",
-      "zod-to-json-schema": "3.25.0"
-   },
-   "devDependencies": {
-      "@types/html2canvas": "0.5.35",
-      "@types/node": "22.19.1",
-      "@types/ws": "8.18.1",
-      "vitest": "4.0.13"
-   },
-   "publishConfig": {
-      "access": "public"
-   }
+  "name": "@hypothesi/tauri-mcp-server",
+  "version": "0.2.0",
+  "description": "A Model Context Protocol server for Tauri v2 development",
+  "type": "module",
+  "bin": {
+    "mcp-server-tauri": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && cp -r src/driver/scripts/*.js dist/driver/scripts/ && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:unit": "vitest run --config vitest.config.unit.ts",
+    "test:e2e": "vitest run --config vitest.config.ts",
+    "dev": "tsc --watch",
+    "generate:docs": "tsx scripts/generate-tools-docs.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hypothesi/mcp-server-tauri.git",
+    "directory": "packages/mcp-server"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": "hypothesi",
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "tauri",
+    "automation",
+    "testing",
+    "debugging",
+    "cursor",
+    "windsurf",
+    "vscode"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "0.6.1",
+    "execa": "9.6.0",
+    "html2canvas": "1.4.1",
+    "ws": "8.18.3",
+    "zod": "3.25.76",
+    "zod-to-json-schema": "3.25.0"
+  },
+  "devDependencies": {
+    "@types/html2canvas": "0.5.35",
+    "@types/node": "22.19.1",
+    "@types/ws": "8.18.1",
+    "vitest": "4.0.13"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }