@hypothesi/tauri-mcp-server 0.8.3 → 0.10.0

package/dist/server.js

@@ -0,0 +1,110 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { TOOLS, TOOL_MAP } from './tools-registry.js';
+import { PROMPTS, PROMPT_MAP } from './prompts-registry.js';
+import { createMcpLogger } from './logger.js';
+/* eslint-disable no-process-exit */
+const serverLogger = createMcpLogger('SERVER');
+export function getCliToolDefinitions() {
+    return TOOLS.map((tool) => {
+        return {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: zodToJsonSchema(tool.schema),
+        };
+    });
+}
+function toolResultToContent(result) {
+    if (typeof result === 'string') {
+        return [{ type: 'text', text: result }];
+    }
+    if (Array.isArray(result)) {
+        return result.map(contentToMcp);
+    }
+    return [contentToMcp(result)];
+}
+function contentToMcp(content) {
+    if (content.type === 'text') {
+        return { type: 'text', text: content.text };
+    }
+    return { type: 'image', data: content.data, mimeType: content.mimeType };
+}
+export function createMcpServer(info) {
+    const server = new Server({
+        name: info.name,
+        version: info.version,
+    }, {
+        capabilities: {
+            tools: {},
+            prompts: {},
+        },
+    });
+    server.onerror = (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('broken pipe') || message.includes('EPIPE')) {
+            process.exit(0);
+        }
+        serverLogger.error(message);
+    };
+    server.onclose = () => {
+        process.exit(0);
+    };
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: TOOLS.map((tool) => {
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: zodToJsonSchema(tool.schema),
+                    annotations: tool.annotations,
+                };
+            }),
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            const tool = TOOL_MAP.get(request.params.name);
+            if (!tool) {
+                throw new Error(`Unknown tool: ${request.params.name}`);
+            }
+            const output = await tool.handler(request.params.arguments);
+            return { content: toolResultToContent(output) };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: 'text', text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: PROMPTS.map((prompt) => {
+                return {
+                    name: prompt.name,
+                    description: prompt.description,
+                    arguments: prompt.arguments,
+                };
+            }),
+        };
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const prompt = PROMPT_MAP.get(request.params.name);
+        if (!prompt) {
+            throw new Error(`Unknown prompt: ${request.params.name}`);
+        }
+        const args = (request.params.arguments || {});
+        return {
+            description: prompt.description,
+            messages: prompt.handler(args),
+        };
+    });
+    return server;
+}
+export async function startStdioServer(info) {
+    const transport = new StdioServerTransport(), server = createMcpServer(info);
+    await server.connect(transport);
+}

package/dist/tools-registry.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Single source of truth for all MCP tool definitions
+ * This file defines all available tools and their metadata
+ */
+import { z } from 'zod';
+/**
+ * Content types that tools can return.
+ * Text content is the default, image content is used for screenshots.
+ */
+export interface TextContent {
+    type: 'text';
+    text: string;
+}
+export interface ImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export type ToolContent = TextContent | ImageContent;
+/**
+ * Tool result can be a string (legacy, converted to TextContent) or structured content.
+ */
+export type ToolResult = string | ToolContent | ToolContent[];
+export type ToolHandler = (args: unknown) => Promise<ToolResult>;
+/**
+ * Tool annotations that help the AI understand when and how to use tools.
+ * These follow the MCP specification for ToolAnnotations.
+ */
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    category: string;
+    schema: z.ZodSchema;
+    handler: ToolHandler;
+    annotations?: ToolAnnotations;
+}
+/**
+ * Tool categories for organization
+ */
+export declare const TOOL_CATEGORIES: {
+    readonly SETUP: "Setup & Configuration";
+    readonly MOBILE_DEVELOPMENT: "Mobile Development";
+    readonly UI_AUTOMATION: "UI Automation & WebView Interaction";
+    readonly IPC_PLUGIN: "IPC & Plugin Tools (via MCP Bridge)";
+};
+/**
+ * Complete registry of all available tools
+ * This is the single source of truth for tool definitions
+ */
+export declare const TOOLS: ToolDefinition[];
+/**
+ * Get all tool names for type checking
+ */
+export type ToolName = typeof TOOLS[number]['name'];
+/**
+ * Get tools grouped by category
+ */
+export declare function getToolsByCategory(): Record<string, ToolDefinition[]>;
+/**
+ * Get total tool count
+ */
+export declare function getToolCount(): number;
+/**
+ * Create a Map for fast tool lookup by name
+ */
+export declare const TOOL_MAP: Map<string, ToolDefinition>;

package/dist/tools-registry.js

@@ -8,6 +8,7 @@ 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, domSnapshot, InteractSchema, ScreenshotSchema, KeyboardSchema, WaitForSchema, GetStylesSchema, ExecuteJavaScriptSchema, FindElementSchema, DomSnapshotSchema, } from './driver/webview-interactions.js';
+import { selectElement, getPointedElement, SelectElementSchema, GetPointedElementSchema, } from './driver/element-picker.js';
 import { PLUGIN_VERSION_CARGO } from './version.js';
 /**
  * Standard multi-app description for webview tools.
@@ -409,6 +410,56 @@ export const TOOLS = [
             });
         },
     },
+    // Element Picker Tools
+    {
+        name: 'webview_select_element',
+        description: '[Tauri Apps Only] Activates an element picker overlay in the Tauri app. ' +
+            'The user visually selects an element by clicking it, and the tool returns ' +
+            'rich element metadata (tag, id, classes, attributes, text, bounding rect, ' +
+            'CSS selector, computed styles, parent chain) plus an annotated screenshot ' +
+            'with the element highlighted. ' +
+            'Requires active driver_session. ' +
+            MULTI_APP_DESC,
+        category: TOOL_CATEGORIES.UI_AUTOMATION,
+        schema: SelectElementSchema,
+        annotations: {
+            title: 'Select Element (Visual Picker)',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const parsed = SelectElementSchema.parse(args);
+            return await selectElement({
+                timeout: parsed.timeout,
+                windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
+            });
+        },
+    },
+    {
+        name: 'webview_get_pointed_element',
+        description: '[Tauri Apps Only] Retrieves element metadata for an element the user previously ' +
+            'pointed at via Alt+Shift+Click in the Tauri app. Returns the same rich metadata ' +
+            'as webview_select_element (tag, id, classes, attributes, text, bounding rect, ' +
+            'CSS selector, computed styles, parent chain) plus an annotated screenshot. ' +
+            'The user must Alt+Shift+Click an element first before calling this tool. ' +
+            'Requires active driver_session. ' +
+            MULTI_APP_DESC,
+        category: TOOL_CATEGORIES.UI_AUTOMATION,
+        schema: GetPointedElementSchema,
+        annotations: {
+            title: 'Get Pointed Element',
+            readOnlyHint: true,
+            openWorldHint: false,
+        },
+        handler: async (args) => {
+            const parsed = GetPointedElementSchema.parse(args);
+            return await getPointedElement({
+                windowId: parsed.windowId,
+                appIdentifier: parsed.appIdentifier,
+            });
+        },
+    },
     // IPC & Plugin Tools
     {
         name: 'ipc_execute_command',

package/dist/types/window.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Window type definitions for multi-webview support.
+ */
+/**
+ * Information about a webview window.
+ */
+export interface WindowInfo {
+    label: string;
+    title?: string;
+    url?: string;
+    focused: boolean;
+    visible: boolean;
+    isMain: boolean;
+}
+/**
+ * Response from the list_windows command.
+ */
+export interface ListWindowsResponse {
+    windows: WindowInfo[];
+    defaultWindow: string;
+    totalCount: number;
+}
+/**
+ * Context about which window was used for an operation.
+ */
+export interface WindowContext {
+    windowLabel: string;
+    totalWindows: number;
+    warning?: string;
+}

package/dist/version.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Version information for the MCP Bridge plugin.
+ *
+ * Reads the version from this package's package.json at runtime.
+ * Both packages share the same version (monorepo single-version policy).
+ */
+/**
+ * Full version string (e.g., "0.6.5")
+ */
+export declare const PLUGIN_VERSION_FULL: string;
+/**
+ * Cargo-compatible version string for Cargo.toml dependencies (e.g., "0.6")
+ * This is the major.minor version used in Cargo.toml dependency specifications.
+ */
+export declare const PLUGIN_VERSION_CARGO: string;

package/package.json

@@ -1,9 +1,17 @@
 {
   "name": "@hypothesi/tauri-mcp-server",
-  "version": "0.8.3",
+  "version": "0.10.0",
   "mcpName": "io.github.hypothesi/mcp-server-tauri",
   "description": "A Model Context Protocol server for use with Tauri v2 applications",
   "type": "module",
+  "main": "./dist/api.js",
+  "types": "./dist/api.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/api.js",
+      "types": "./dist/api.d.ts"
+    }
+  },
   "bin": {
     "mcp-server-tauri": "./dist/index.js"
   },