@hypothesi/tauri-mcp-server 0.9.0 → 0.10.0

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/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>;

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/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.9.0",
+  "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"
   },