@hypothesi/tauri-mcp-server 0.9.0 → 0.11.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/driver/webview-interactions.js

@@ -22,7 +22,8 @@ export const WindowTargetSchema = z.object({
  * Defaults to 'css' for backward compatibility.
  */
 const selectorStrategyField = z.enum(['css', 'xpath', 'text']).default('css').describe('Selector strategy: "css" (default) for CSS selectors, "xpath" for XPath expressions, ' +
-    '"text" to find elements containing the given text. Ref IDs (e.g., "ref=e3") work with any strategy.');
+    '"text" to find elements by text content, with fallback to placeholder, aria-label, ' +
+    'and title attributes. Ref IDs (e.g., "ref=e3") work with any strategy.');
 // ============================================================================
 // Schemas
 // ============================================================================
@@ -154,10 +155,8 @@ export async function screenshot(options = {}) {
         if (!imageContent || imageContent.type !== 'image') {
             throw new Error('Screenshot capture failed: no image data');
         }
-        // Decode base64 and write to file
-        const buffer = Buffer.from(imageContent.data, 'base64');
         const resolvedPath = resolve(filePath);
-        await writeFile(resolvedPath, buffer);
+        await writeFile(resolvedPath, imageContent.data, 'base64');
         return { filePath: resolvedPath, format };
     }
     return result;
@@ -295,7 +294,7 @@ export async function domSnapshot(options) {
     const { type, selector, strategy, windowId, appIdentifier } = options;
     // Only load aria-api for accessibility snapshots
     if (type === 'accessibility') {
-        await ensureAriaApiLoaded(windowId);
+        await ensureAriaApiLoaded(windowId, appIdentifier);
     }
     // Then execute the snapshot script
     const script = buildScript(SCRIPTS.domSnapshot, { type, selector: selector ?? null, strategy: strategy ?? 'css' });
@@ -311,11 +310,11 @@ export async function domSnapshot(options) {
  * Ensure aria-api library is loaded in the webview.
  * Uses the script manager to inject the library if not already present.
  */
-async function ensureAriaApiLoaded(windowId) {
+async function ensureAriaApiLoaded(windowId, appIdentifier) {
     const { getAriaApiSource, ARIA_API_SCRIPT_ID: ariaApiScriptId } = await import('./scripts/aria-api-loader.js');
     const { registerScript, isScriptRegistered } = await import('./script-manager.js');
-    if (await isScriptRegistered(ariaApiScriptId)) {
+    if (await isScriptRegistered(ariaApiScriptId, appIdentifier)) {
         return;
     }
-    await registerScript(ariaApiScriptId, 'inline', getAriaApiSource(), windowId);
+    await registerScript(ariaApiScriptId, 'inline', getAriaApiSource(), windowId, appIdentifier);
 }

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