rsbuild-plugin-vue-mcp 0.1.0

package/dist/rspack.cjs

@@ -0,0 +1,446 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    VueMcpPlugin: ()=>VueMcpPlugin
+});
+const external_node_url_namespaceObject = require("node:url");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_ws_namespaceObject = require("ws");
+const external_hookable_namespaceObject = require("hookable");
+function createVueMcpContext() {
+    return {
+        hooks: (0, external_hookable_namespaceObject.createHooks)(),
+        rpc: null,
+        rpcServer: null
+    };
+}
+function createServerRpcFunc(ctx) {
+    return {
+        getInspectorTree: (_)=>({}),
+        onInspectorTreeUpdated: (event, data)=>{
+            ctx.hooks.callHook(event, data).finally();
+        },
+        getInspectorState: (_)=>({}),
+        onInspectorStateUpdated: (event, data)=>{
+            ctx.hooks.callHook(event, data).finally();
+        },
+        editComponentState (_) {},
+        highlightComponent (_) {},
+        getRouterInfo: (_)=>({}),
+        onRouterInfoUpdated: (event, data)=>{
+            ctx.hooks.callHook(event, data).finally();
+        },
+        getPiniaTree: (_)=>({}),
+        onPiniaTreeUpdated: (event, data)=>{
+            ctx.hooks.callHook(event, data).finally();
+        },
+        getPiniaState: (_)=>({}),
+        onPiniaInfoUpdated: (event, data)=>{
+            ctx.hooks.callHook(event, data).finally();
+        }
+    };
+}
+const external_birpc_namespaceObject = require("birpc");
+const channelCache = new WeakMap();
+function createRPCServer(ws, functions, options = {}) {
+    const group = (0, external_birpc_namespaceObject.createBirpcGroup)(functions, ()=>Array.from(ws?.clients || []).map((channel)=>{
+            if (channel.readyState === channel.CLOSED) return;
+            const cached = channelCache.get(channel);
+            if (cached) return cached;
+            const options = {
+                on: (fn)=>channel.on('message', fn),
+                post: (data)=>channel.send(data),
+                serialize: (v)=>JSON.stringify(v),
+                deserialize: (v)=>JSON.parse(v)
+            };
+            channelCache.set(channel, options);
+            return options;
+        }).filter((c)=>!!c), options);
+    ws.on('connection', ()=>{
+        group.updateChannels();
+    });
+    return group.broadcast;
+}
+const mcp_js_namespaceObject = require("@modelcontextprotocol/sdk/server/mcp.js");
+var package_namespaceObject = {
+    rE: "0.1.0"
+};
+const external_nanoid_namespaceObject = require("nanoid");
+const external_zod_namespaceObject = require("zod");
+function stringify(value) {
+    return "string" == typeof value ? value : JSON.stringify(value);
+}
+function createMcpServerDefault(options, ctx) {
+    const server = new mcp_js_namespaceObject.McpServer({
+        name: "rsbuild-vue-mcp",
+        description: 'Rsbuild/Rspack MCP plugin based on Vue DevTools',
+        version: package_namespaceObject.rE,
+        ...options.mcpServerInfo
+    });
+    server.registerTool('get-component-tree', {
+        description: 'Get the Vue component tree in markdown tree syntax format.'
+    }, async ()=>new Promise((resolve, reject)=>{
+            const eventName = (0, external_nanoid_namespaceObject.nanoid)();
+            ctx.hooks.hookOnce(eventName, (res)=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: stringify(res)
+                        }
+                    ]
+                });
+            });
+            ctx.rpcServer.getInspectorTree({
+                event: eventName
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('get-component-state', {
+        description: 'Get the Vue component state in JSON structure format.',
+        inputSchema: {
+            componentName: external_zod_namespaceObject.z.string()
+        }
+    }, async ({ componentName })=>new Promise((resolve, reject)=>{
+            const eventName = (0, external_nanoid_namespaceObject.nanoid)();
+            ctx.hooks.hookOnce(eventName, (res)=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: stringify(res)
+                        }
+                    ]
+                });
+            });
+            ctx.rpcServer.getInspectorState({
+                event: eventName,
+                componentName
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('edit-component-state', {
+        description: 'Edit the Vue component state.',
+        inputSchema: {
+            componentName: external_zod_namespaceObject.z.string(),
+            path: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+            value: external_zod_namespaceObject.z.string(),
+            valueType: external_zod_namespaceObject.z["enum"]([
+                'string',
+                'number',
+                'boolean',
+                'object',
+                'array'
+            ])
+        }
+    }, async ({ componentName, path, value, valueType })=>new Promise((resolve, reject)=>{
+            ctx.rpcServer.editComponentState({
+                componentName,
+                path,
+                value,
+                valueType
+            }).then(()=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'ok'
+                        }
+                    ]
+                });
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('highlight-component', {
+        description: 'Highlight the Vue component.',
+        inputSchema: {
+            componentName: external_zod_namespaceObject.z.string()
+        }
+    }, async ({ componentName })=>new Promise((resolve, reject)=>{
+            ctx.rpcServer.highlightComponent({
+                componentName
+            }).then(()=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'ok'
+                        }
+                    ]
+                });
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('get-router-info', {
+        description: 'Get the Vue router info in JSON structure format.'
+    }, async ()=>new Promise((resolve, reject)=>{
+            const eventName = (0, external_nanoid_namespaceObject.nanoid)();
+            ctx.hooks.hookOnce(eventName, (res)=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: stringify(res)
+                        }
+                    ]
+                });
+            });
+            ctx.rpcServer.getRouterInfo({
+                event: eventName
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('get-pinia-state', {
+        description: 'Get the Pinia state in JSON structure format.',
+        inputSchema: {
+            storeName: external_zod_namespaceObject.z.string()
+        }
+    }, async ({ storeName })=>new Promise((resolve, reject)=>{
+            const eventName = (0, external_nanoid_namespaceObject.nanoid)();
+            ctx.hooks.hookOnce(eventName, (res)=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: stringify(res)
+                        }
+                    ]
+                });
+            });
+            ctx.rpcServer.getPiniaState({
+                event: eventName,
+                storeName
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    server.registerTool('get-pinia-tree', {
+        description: 'Get the Pinia tree in JSON structure format.'
+    }, async ()=>new Promise((resolve, reject)=>{
+            const eventName = (0, external_nanoid_namespaceObject.nanoid)();
+            ctx.hooks.hookOnce(eventName, (res)=>{
+                resolve({
+                    content: [
+                        {
+                            type: 'text',
+                            text: stringify(res)
+                        }
+                    ]
+                });
+            });
+            ctx.rpcServer.getPiniaTree({
+                event: eventName
+            }).catch((e)=>{
+                console.error(e);
+                reject(e);
+            });
+        }));
+    return server;
+}
+const streamableHttp_js_namespaceObject = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+async function mcpHandlerStateless(server, req, res) {
+    try {
+        const transport = new streamableHttp_js_namespaceObject.StreamableHTTPServerTransport({
+            sessionIdGenerator: void 0
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res);
+        res.on('close', ()=>{
+            transport.close();
+            server.close();
+        });
+    } catch (error) {
+        console.error('Error handling MCP request:', error);
+        if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader('content-type', 'application/json');
+            res.end(JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32603,
+                    message: 'Internal server error'
+                },
+                id: null
+            }));
+        }
+    }
+}
+function setupRspackRoutes(base, getServer, middlewares) {
+    middlewares.push({
+        name: 'vue-devtools-mcp',
+        path: `${base}/mcp`,
+        async middleware (req, res) {
+            const server = await getServer();
+            await mcpHandlerStateless(server, req, res);
+        }
+    });
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function getVueMcpPath() {
+    const pluginPath = external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
+    return pluginPath.replaceAll('\\', '/');
+}
+function getOverlayBootstrapPath() {
+    const fileUrl = new URL('./overlay-bootstrap.js', __rslib_import_meta_url__);
+    return (0, external_node_url_namespaceObject.fileURLToPath)(fileUrl).replaceAll('\\', '/').replace('/src/', '/dist/');
+}
+const PLUGIN_NAME = "VueMcpPlugin";
+class VueMcpPlugin {
+    applyInspector(compiler) {}
+    applyHtmlInjection(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            const hooks = compiler.rspack.HtmlRspackPlugin.getCompilationHooks(compilation);
+            if (!hooks.alterAssetTags) return;
+            hooks.alterAssetTags.tap(PLUGIN_NAME, (data)=>{
+                const overlayPath = getOverlayBootstrapPath();
+                try {
+                    const js = external_node_fs_default().readFileSync(overlayPath, {
+                        encoding: 'utf8'
+                    });
+                    data.assetTags.scripts.push({
+                        tagName: "script",
+                        voidTag: false,
+                        attributes: {
+                            id: 'overlay-bootstrap.js'
+                        },
+                        innerHTML: js
+                    });
+                    console.log('  ➜  VueDevtools MCP: injection html => overlay-bootstrap.js');
+                } catch (e) {}
+                return data;
+            });
+        });
+    }
+    apply(compiler) {
+        if ('production' === compiler.options.mode) return;
+        const ctx = createVueMcpContext();
+        getVueMcpPath();
+        const wsPath = '/__vue-devtools-mcp-ws';
+        this.applyInspector(compiler);
+        this.applyHtmlInjection(compiler);
+        compiler.hooks.environment.tap(PLUGIN_NAME, ()=>{
+            if (false === compiler.options.devServer) return;
+            compiler.options.devServer ??= {};
+            const rawSetupMiddlewares = compiler.options.devServer.setupMiddlewares;
+            compiler.options.devServer.setupMiddlewares = (middlewares, devServer)=>{
+                if ('function' == typeof rawSetupMiddlewares) middlewares = rawSetupMiddlewares.call(compiler.options.devServer, middlewares, devServer);
+                if (!devServer) {
+                    console.warn('❌ rspack-dev-server is not defined here.');
+                    return middlewares;
+                }
+                const httpServer = devServer.server;
+                if (!httpServer) {
+                    console.error('❌ [vue-devtools-mcp] no rspack devServer.server, require @rspack/core >= 1.3');
+                    return middlewares;
+                }
+                const wss = new external_ws_namespaceObject.WebSocketServer({
+                    noServer: true
+                });
+                wss.on('connection', ()=>{
+                    console.debug('✅ Client connected to vue-devtools-mcp WebSocket!');
+                });
+                httpServer.on('upgrade', (request, socket, head)=>{
+                    const { pathname } = new URL(request.url || '', 'wss://base.url');
+                    if (pathname !== wsPath) return;
+                    wss.handleUpgrade(request, socket, head, (client)=>{
+                        wss.emit('connection', client, request);
+                    });
+                });
+                const rpc = createServerRpcFunc(ctx);
+                ctx.rpcServer = createRPCServer(wss, rpc, {
+                    timeout: 3000
+                });
+                ctx.rpc = rpc;
+                const { printUrl = true, mcpPath = '/__mcp' } = this.options;
+                setupRspackRoutes(mcpPath, async ()=>{
+                    let mcp = createMcpServerDefault(this.options, ctx);
+                    mcp = await this.options.mcpServerSetup?.(mcp, compiler) || mcp;
+                    return mcp;
+                }, middlewares);
+                if (printUrl) {
+                    const port = (compiler.options.devServer || {}).port || 8080;
+                    const mcpUrl = `http://localhost:${port}${mcpPath}/mcp`;
+                    setTimeout(()=>{
+                        if (devServer.logger?.info) devServer.logger.info(`  ➜  MCP:     Server is running at ${mcpUrl}`);
+                        else console.log(`  ➜  MCP:     Server is running at ${mcpUrl}`);
+                    }, 300);
+                }
+                return middlewares;
+            };
+        });
+    }
+    constructor(options = {}){
+        _define_property(this, "name", PLUGIN_NAME);
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+}
+exports.VueMcpPlugin = __webpack_exports__.VueMcpPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "VueMcpPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/rspack.js

@@ -0,0 +1,115 @@
+import { fileURLToPath } from "node:url";
+import node_path from "node:path";
+import node_fs from "node:fs";
+import { WebSocketServer } from "ws";
+import { createMcpServerDefault, createVueMcpContext, createRPCServer, createServerRpcFunc, setupRspackRoutes } from "./551.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function getVueMcpPath() {
+    const pluginPath = node_path.dirname(fileURLToPath(import.meta.url));
+    return pluginPath.replaceAll('\\', '/');
+}
+function getOverlayBootstrapPath() {
+    const fileUrl = new URL('./overlay-bootstrap.js', import.meta.url);
+    return fileURLToPath(fileUrl).replaceAll('\\', '/').replace('/src/', '/dist/');
+}
+const PLUGIN_NAME = "VueMcpPlugin";
+class VueMcpPlugin {
+    applyInspector(compiler) {}
+    applyHtmlInjection(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            const hooks = compiler.rspack.HtmlRspackPlugin.getCompilationHooks(compilation);
+            if (!hooks.alterAssetTags) return;
+            hooks.alterAssetTags.tap(PLUGIN_NAME, (data)=>{
+                const overlayPath = getOverlayBootstrapPath();
+                try {
+                    const js = node_fs.readFileSync(overlayPath, {
+                        encoding: 'utf8'
+                    });
+                    data.assetTags.scripts.push({
+                        tagName: "script",
+                        voidTag: false,
+                        attributes: {
+                            id: 'overlay-bootstrap.js'
+                        },
+                        innerHTML: js
+                    });
+                    console.log('  ➜  VueDevtools MCP: injection html => overlay-bootstrap.js');
+                } catch (e) {}
+                return data;
+            });
+        });
+    }
+    apply(compiler) {
+        if ('production' === compiler.options.mode) return;
+        const ctx = createVueMcpContext();
+        getVueMcpPath();
+        const wsPath = '/__vue-devtools-mcp-ws';
+        this.applyInspector(compiler);
+        this.applyHtmlInjection(compiler);
+        compiler.hooks.environment.tap(PLUGIN_NAME, ()=>{
+            if (false === compiler.options.devServer) return;
+            compiler.options.devServer ??= {};
+            const rawSetupMiddlewares = compiler.options.devServer.setupMiddlewares;
+            compiler.options.devServer.setupMiddlewares = (middlewares, devServer)=>{
+                if ('function' == typeof rawSetupMiddlewares) middlewares = rawSetupMiddlewares.call(compiler.options.devServer, middlewares, devServer);
+                if (!devServer) {
+                    console.warn('❌ rspack-dev-server is not defined here.');
+                    return middlewares;
+                }
+                const httpServer = devServer.server;
+                if (!httpServer) {
+                    console.error('❌ [vue-devtools-mcp] no rspack devServer.server, require @rspack/core >= 1.3');
+                    return middlewares;
+                }
+                const wss = new WebSocketServer({
+                    noServer: true
+                });
+                wss.on('connection', ()=>{
+                    console.debug('✅ Client connected to vue-devtools-mcp WebSocket!');
+                });
+                httpServer.on('upgrade', (request, socket, head)=>{
+                    const { pathname } = new URL(request.url || '', 'wss://base.url');
+                    if (pathname !== wsPath) return;
+                    wss.handleUpgrade(request, socket, head, (client)=>{
+                        wss.emit('connection', client, request);
+                    });
+                });
+                const rpc = createServerRpcFunc(ctx);
+                ctx.rpcServer = createRPCServer(wss, rpc, {
+                    timeout: 3000
+                });
+                ctx.rpc = rpc;
+                const { printUrl = true, mcpPath = '/__mcp' } = this.options;
+                setupRspackRoutes(mcpPath, async ()=>{
+                    let mcp = createMcpServerDefault(this.options, ctx);
+                    mcp = await this.options.mcpServerSetup?.(mcp, compiler) || mcp;
+                    return mcp;
+                }, middlewares);
+                if (printUrl) {
+                    const port = (compiler.options.devServer || {}).port || 8080;
+                    const mcpUrl = `http://localhost:${port}${mcpPath}/mcp`;
+                    setTimeout(()=>{
+                        if (devServer.logger?.info) devServer.logger.info(`  ➜  MCP:     Server is running at ${mcpUrl}`);
+                        else console.log(`  ➜  MCP:     Server is running at ${mcpUrl}`);
+                    }, 300);
+                }
+                return middlewares;
+            };
+        });
+    }
+    constructor(options = {}){
+        _define_property(this, "name", PLUGIN_NAME);
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+}
+export { VueMcpPlugin };

package/dist/types/core/dev-rpc.d.ts

@@ -0,0 +1,3 @@
+import type { BirpcGroupReturn, EventOptions } from "birpc";
+import type { WebSocketServer } from "ws";
+export declare function createRPCServer<ClientFunction, ServerFunctions extends object>(ws: WebSocketServer, functions: ServerFunctions, options?: EventOptions<ClientFunction, ServerFunctions>): BirpcGroupReturn<ClientFunction>;

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin, RsbuildPluginAPI } from "@rsbuild/core";
+import type { PluginVueMcpOptions } from "./types.ts";
+export declare const pluginVueMcp: (options?: PluginVueMcpOptions<RsbuildPluginAPI>) => RsbuildPlugin;

package/dist/types/mcp/connect.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { RsbuildDevServer } from "@rsbuild/core";
+import type { DevServerMiddleware } from "@rspack/core";
+export declare function setupRoutes<DEV extends RsbuildDevServer>(base: string, getServer: () => Promise<McpServer>, dev: DEV): void;
+export declare function setupRspackRoutes(base: string, getServer: () => Promise<McpServer>, middlewares: DevServerMiddleware[]): void;

package/dist/types/mcp/context.d.ts

@@ -0,0 +1,2 @@
+import type { VueMcpContext } from "../types.ts";
+export declare function createVueMcpContext(): VueMcpContext;

package/dist/types/mcp/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { RpcFunctions, VueMcpContext } from "../types.ts";
+export declare function createServerRpcFunc(ctx: VueMcpContext): RpcFunctions;

package/dist/types/mcp/server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { PluginVueMcpOptions, VueMcpContext } from "../types.ts";
+import type { RsbuildPluginAPI } from "@rsbuild/core";
+import type { Compiler as RspackCompiler } from "@rspack/core";
+export declare function createMcpServerDefault<DEV extends RsbuildPluginAPI | RspackCompiler>(options: PluginVueMcpOptions<DEV>, ctx: VueMcpContext): McpServer;

package/dist/types/rspack.d.ts

@@ -0,0 +1,10 @@
+import type { Compiler, RspackPluginInstance } from "@rspack/core";
+import type { PluginVueMcpOptions } from "./types.ts";
+export declare class VueMcpPlugin implements RspackPluginInstance {
+    readonly name = "VueMcpPlugin";
+    private readonly options;
+    constructor(options?: PluginVueMcpOptions<Compiler>);
+    private applyInspector;
+    private applyHtmlInjection;
+    apply(compiler: Compiler): void;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,77 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { Implementation as McpServerInfo } from '@modelcontextprotocol/sdk/types.js';
+import type { Hookable } from "hookable";
+import type { BirpcGroupReturn } from "birpc";
+export type Awaitable<T> = T | Promise<T>;
+export interface RpcFunctions {
+    getInspectorTree: (options: {
+        event: string;
+        componentName?: string;
+    }) => void;
+    onInspectorTreeUpdated: (event: string, data: string) => void;
+    getInspectorState: (options: {
+        event: string;
+        componentName: string;
+    }) => void;
+    onInspectorStateUpdated: (event: string, data: string) => void;
+    editComponentState: (options: {
+        componentName: string;
+        path: string[];
+        value: string;
+        valueType: string;
+    }) => void;
+    highlightComponent: (options: {
+        componentName: string;
+    }) => void;
+    getRouterInfo: (options: {
+        event: string;
+    }) => void;
+    onRouterInfoUpdated: (event: string, data: string) => void;
+    getPiniaState: (options: {
+        event: string;
+        storeName: string;
+    }) => void;
+    onPiniaInfoUpdated: (event: string, data: string) => void;
+    getPiniaTree: (options: {
+        event: string;
+    }) => void;
+    onPiniaTreeUpdated: (event: string, data: string) => void;
+}
+export interface VueMcpContext {
+    hooks: Hookable;
+    rpc: RpcFunctions;
+    rpcServer: BirpcGroupReturn<RpcFunctions>;
+}
+export interface PluginVueMcpOptions<DEV> {
+    /**
+     * The host to listen on, default is `localhost`
+     */
+    host?: string;
+    /**
+     * Print the MCP server URL in the console
+     *
+     * @default true
+     */
+    printUrl?: boolean;
+    /**
+     * The MCP server info. Ingored when `mcpServer` is provided
+     */
+    mcpServerInfo?: McpServerInfo;
+    /**
+     * Setup the MCP server, this is called when the MCP server is created
+     * You may also return a new MCP server to replace the default one
+     */
+    mcpServerSetup?: (server: McpServer, api: DEV) => Awaitable<void | McpServer>;
+    /**
+     * The path to the MCP server, default is `/__mcp`
+     */
+    mcpPath?: string;
+    /**
+     * append an import to the module id ending with `appendTo` instead of adding a script into body
+     * useful for projects that do not use html file as an entry
+     *
+     * WARNING: only set this if you know exactly what it does.
+     * @default ''
+     */
+    appendTo?: string | RegExp;
+}