@hypothesi/tauri-mcp-server 0.8.3 → 0.10.0

package/dist/driver/webview-interactions.d.ts

@@ -0,0 +1,349 @@
+import { z } from 'zod';
+import { ScreenshotResult } from './webview-executor.js';
+/**
+ * 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 declare const WindowTargetSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export declare const InteractSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    action: z.ZodEnum<["click", "double-click", "long-press", "scroll", "swipe", "focus"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    scrollX: z.ZodOptional<z.ZodNumber>;
+    scrollY: z.ZodOptional<z.ZodNumber>;
+    fromX: z.ZodOptional<z.ZodNumber>;
+    fromY: z.ZodOptional<z.ZodNumber>;
+    toX: z.ZodOptional<z.ZodNumber>;
+    toY: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+    duration?: number | undefined;
+    scrollX?: number | undefined;
+    scrollY?: number | undefined;
+    fromX?: number | undefined;
+    fromY?: number | undefined;
+    toX?: number | undefined;
+    toY?: number | undefined;
+}, {
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+    duration?: number | undefined;
+    scrollX?: number | undefined;
+    scrollY?: number | undefined;
+    fromX?: number | undefined;
+    fromY?: number | undefined;
+    toX?: number | undefined;
+    toY?: number | undefined;
+}>;
+export declare const ScreenshotSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
+    quality: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    filePath: z.ZodOptional<z.ZodString>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    format: "png" | "jpeg";
+    quality: number;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    maxWidth?: number | undefined;
+    filePath?: string | undefined;
+}, {
+    format?: "png" | "jpeg" | undefined;
+    quality?: number | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    maxWidth?: number | undefined;
+    filePath?: string | undefined;
+}>;
+export declare const KeyboardSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    action: z.ZodEnum<["type", "press", "down", "up"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    text: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodOptional<z.ZodArray<z.ZodEnum<["Control", "Alt", "Shift", "Meta"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    action: "type" | "press" | "down" | "up";
+    strategy: "css" | "text" | "xpath";
+    text?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    key?: string | undefined;
+    modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
+}, {
+    action: "type" | "press" | "down" | "up";
+    text?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    key?: string | undefined;
+    modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
+}>;
+export declare const WaitForSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    type: z.ZodEnum<["selector", "text", "ipc-event"]>;
+    value: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "text" | "selector" | "ipc-event";
+    strategy: "css" | "text" | "xpath";
+    timeout: number;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    value: string;
+    type: "text" | "selector" | "ipc-event";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    timeout?: number | undefined;
+}>;
+export declare const GetStylesSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    multiple: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    strategy: "css" | "text" | "xpath";
+    multiple: boolean;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    properties?: string[] | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    properties?: string[] | undefined;
+    multiple?: boolean | undefined;
+}>;
+export declare const ExecuteJavaScriptSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    script: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, "strip", z.ZodTypeAny, {
+    script: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    args?: unknown[] | undefined;
+}, {
+    script: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    args?: unknown[] | undefined;
+}>;
+export declare const FocusElementSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export declare const FindElementSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+}>;
+export declare const GetConsoleLogsSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    filter: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}, {
+    filter?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}>;
+export declare const DomSnapshotSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    type: z.ZodEnum<["accessibility", "structure"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "accessibility" | "structure";
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+}, {
+    type: "accessibility" | "structure";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+}>;
+export declare function interact(options: {
+    action: string;
+    selector?: string;
+    strategy?: string;
+    x?: number;
+    y?: number;
+    duration?: number;
+    scrollX?: number;
+    scrollY?: number;
+    fromX?: number;
+    fromY?: number;
+    toX?: number;
+    toY?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+}): Promise<string>;
+export interface ScreenshotOptions {
+    quality?: number;
+    format?: 'png' | 'jpeg';
+    windowId?: string;
+    filePath?: string;
+    appIdentifier?: string | number;
+    maxWidth?: number;
+}
+export interface ScreenshotFileResult {
+    filePath: string;
+    format: 'png' | 'jpeg';
+}
+export declare function screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult | ScreenshotFileResult>;
+export interface KeyboardOptions {
+    action: string;
+    selectorOrKey?: string;
+    strategy?: string;
+    textOrModifiers?: string | string[];
+    modifiers?: string[];
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function keyboard(options: KeyboardOptions): Promise<string>;
+export interface WaitForOptions {
+    type: string;
+    value: string;
+    strategy?: string;
+    timeout?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function waitFor(options: WaitForOptions): Promise<string>;
+export interface GetStylesOptions {
+    selector: string;
+    strategy?: string;
+    properties?: string[];
+    multiple?: boolean;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function getStyles(options: GetStylesOptions): Promise<string>;
+export interface ExecuteJavaScriptOptions {
+    script: string;
+    args?: unknown[];
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function executeJavaScript(options: ExecuteJavaScriptOptions): Promise<string>;
+export interface FocusElementOptions {
+    selector: string;
+    strategy?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function focusElement(options: FocusElementOptions): Promise<string>;
+export interface FindElementOptions {
+    selector: string;
+    strategy: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Find an element using various selector strategies.
+ */
+export declare function findElement(options: FindElementOptions): Promise<string>;
+export interface GetConsoleLogsOptions {
+    filter?: string;
+    since?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Get console logs from the webview.
+ */
+export declare function getConsoleLogs(options?: GetConsoleLogsOptions): Promise<string>;
+export interface DomSnapshotOptions {
+    type: 'accessibility' | 'structure';
+    selector?: string;
+    strategy?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Generate a structured DOM snapshot for AI consumption.
+ * Uses aria-api for comprehensive, spec-compliant accessibility computation.
+ */
+export declare function domSnapshot(options: DomSnapshotOptions): Promise<string>;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -1,132 +1,18 @@
 #!/usr/bin/env node
-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 { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-// Import the single source of truth for all tools and prompts
-import { TOOLS, TOOL_MAP } from './tools-registry.js';
-import { PROMPTS, PROMPT_MAP } from './prompts-registry.js';
-import { createMcpLogger } from './logger.js';
+import { startStdioServer } from './server.js';
 /* eslint-disable no-process-exit */
 // Read version from package.json
 const currentDir = dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(readFileSync(join(currentDir, '..', 'package.json'), 'utf-8'));
 const VERSION = packageJson.version;
-const serverLogger = createMcpLogger('SERVER');
-// Initialize server
-const server = new Server({
-    name: 'mcp-server-tauri',
-    version: VERSION,
-}, {
-    capabilities: {
-        tools: {},
-        prompts: {},
-    },
-});
-// Handle connection errors gracefully - don't crash on broken pipe
-server.onerror = (error) => {
-    // Ignore broken pipe errors - they happen when the client disconnects
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes('broken pipe') || message.includes('EPIPE')) {
-        // Client disconnected, exit gracefully
-        process.exit(0);
-    }
-    // For other errors, log to stderr (will be captured by MCP client)
-    serverLogger.error(message);
-};
-// Handle connection close - exit gracefully
-server.onclose = () => {
-    process.exit(0);
-};
-// Tool list handler - generated from registry
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: TOOLS.map((tool) => {
-            return {
-                name: tool.name,
-                description: tool.description,
-                inputSchema: zodToJsonSchema(tool.schema),
-                annotations: tool.annotations,
-            };
-        }),
-    };
-});
-/**
- * Convert a ToolResult to MCP content array.
- * Handles string (legacy), single content, and content arrays.
- */
-function toolResultToContent(result) {
-    // Legacy string result - convert to text content
-    if (typeof result === 'string') {
-        return [{ type: 'text', text: result }];
-    }
-    // Array of content items
-    if (Array.isArray(result)) {
-        return result.map(contentToMcp);
-    }
-    // Single content item
-    return [contentToMcp(result)];
-}
-/**
- * Convert a single ToolContent to MCP format.
- */
-function contentToMcp(content) {
-    if (content.type === 'text') {
-        return { type: 'text', text: content.text };
-    }
-    // Image content
-    return { type: 'image', data: content.data, mimeType: content.mimeType };
-}
-// Tool call handler - generated from registry
-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,
-        };
-    }
-});
-// Prompt list handler - generated from registry
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return {
-        prompts: PROMPTS.map((prompt) => {
-            return {
-                name: prompt.name,
-                description: prompt.description,
-                arguments: prompt.arguments,
-            };
-        }),
-    };
-});
-// Get prompt handler - returns prompt messages for a specific prompt
-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),
-    };
-});
-// Start server
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Don't log to stderr - it interferes with MCP protocol
+    await startStdioServer({
+        name: 'mcp-server-tauri',
+        version: VERSION,
+    });
 }
 main().catch(() => {
     // Don't log errors to stderr - just exit silently

package/dist/logger.d.ts

@@ -0,0 +1,16 @@
+export interface McpLogger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+/**
+ * Creates a logger that writes to stderr only.
+ *
+ * IMPORTANT: MCP uses stdio for JSON-RPC communication. The server sends
+ * JSON responses over stdout, and the client parses them. Any non-JSON
+ * output to stdout (like console.log) will corrupt the protocol and cause
+ * parsing errors like "invalid character 'M' looking for beginning of value".
+ *
+ * All logging MUST go to stderr to avoid interfering with MCP communication.
+ */
+export declare function createMcpLogger(scope: string): McpLogger;

package/dist/manager/mobile.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const ListDevicesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function listDevices(): Promise<{
+    android: string[];
+    ios: string[];
+}>;

package/dist/monitor/logs.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const ReadLogsSchema: z.ZodObject<{
+    source: z.ZodEnum<["console", "android", "ios", "system"]>;
+    lines: z.ZodDefault<z.ZodNumber>;
+    filter: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    lines: number;
+    source: "android" | "ios" | "console" | "system";
+    filter?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}, {
+    source: "android" | "ios" | "console" | "system";
+    filter?: string | undefined;
+    lines?: number | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}>;
+export interface ReadLogsOptions {
+    source: 'console' | 'android' | 'ios' | 'system';
+    lines?: number;
+    filter?: string;
+    since?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function readLogs(options: ReadLogsOptions): Promise<string>;

package/dist/prompts-registry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Single source of truth for all MCP prompt definitions
+ * Prompts are user-controlled templates that appear as slash commands in MCP clients
+ */
+export interface PromptArgument {
+    name: string;
+    description: string;
+    required?: boolean;
+}
+export interface PromptMessage {
+    role: 'user' | 'assistant';
+    content: {
+        type: 'text';
+        text: string;
+    };
+}
+export interface PromptDefinition {
+    name: string;
+    description: string;
+    arguments?: PromptArgument[];
+    handler: (args: Record<string, string>) => PromptMessage[];
+}
+/**
+ * Complete registry of all available prompts
+ */
+export declare const PROMPTS: PromptDefinition[];
+/**
+ * Create a Map for fast prompt lookup by name
+ */
+export declare const PROMPT_MAP: Map<string, PromptDefinition>;

package/dist/prompts-registry.js

@@ -91,6 +91,28 @@ Once changes are approved and made:
 - The plugin only runs in debug builds so it won't affect production
 - The WebSocket server binds to \`0.0.0.0:9223\` by default
 - For localhost-only access, use \`Builder::new().bind_address("127.0.0.1").build()\``;
+const SELECT_ELEMENT_PROMPT = (message) => {
+    const lines = [
+        'The user wants to visually select an element in their running Tauri app so they can discuss it with you.',
+        '',
+        'Follow these steps:',
+        '',
+        '1. **Ensure a session is active** - Use `driver_session` with action "start" if not already connected',
+        '',
+        '2. **Activate the element picker** - Call `webview_select_element` to show the picker overlay in the app.',
+        'The user will see a blue highlight following their cursor and can click to select an element.',
+        'They can press Escape or click X to cancel.',
+        '',
+        '3. **Review the result** - You will receive the element\'s metadata (tag, id, classes, CSS selector, XPath,',
+        'bounding rect, attributes, computed styles, parent chain) and an annotated screenshot with the element highlighted.',
+        '',
+        '4. **Respond to the user** - Use the element context and screenshot to address their request.',
+    ];
+    if (message) {
+        lines.push('', '## User\'s Message About the Element', '', message);
+    }
+    return lines.join('\n');
+};
 /**
  * Complete registry of all available prompts
  */
@@ -114,6 +136,30 @@ export const PROMPTS = [
             ];
         },
     },
+    {
+        name: 'select',
+        description: 'Visually select an element in the running Tauri app. ' +
+            'Activates a picker overlay — click an element to send its metadata and an annotated screenshot to the agent. ' +
+            'Optionally include a message describing what you want to do with the element.',
+        arguments: [
+            {
+                name: 'message',
+                description: 'What you want to discuss or do with the selected element (e.g. "this button should be green instead of blue")',
+                required: false,
+            },
+        ],
+        handler: (args) => {
+            return [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: SELECT_ELEMENT_PROMPT(args.message),
+                    },
+                },
+            ];
+        },
+    },
     {
         name: 'setup',
         description: 'Set up or update the MCP Bridge plugin in a Tauri project. ' +

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export interface McpServerInfo {
+    name: string;
+    version: string;
+}
+export interface CliToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare function getCliToolDefinitions(): CliToolDefinition[];
+export declare function createMcpServer(info: McpServerInfo): Server;
+export declare function startStdioServer(info: McpServerInfo): Promise<void>;